NPrinting has a library of APIs that can be used to customize many native NPrinting functions outside the NPrinting Web Console.

Environment:

Qlik NPrinting 

An example of two of the more common capabilities available via NPrinting APIs are as follows

• Connection reloads
• Publish Task executions

These and many other public NPrinting APIs can be found here: Qlik NPrinting API

In the Qlik Sense data load editor of your Qlik Sense app, two REST connections are required (These two REST Connectors must also be configured in the QlikView Desktop application>load where the API's are used. See Nprinting Rest API Connection through QlikView desktop)

• GET
• POST

Requirements of REST user account:

• Windows Authentication is required in both these connectors. The required user account is the NPrinting service account (which is also ROOTADMIN on the Qlik Sense server)
• This user account must also be a member of the NPrinting 'Administrators' Security Role on the NPrinting Server.

Creating REST "GET" connections

Note: Replace QlikServer3.domain.local with the name and port of your NPrinting Server

NOTE: replace domain\administrator with the domain and user name of your NPrinting service user account

Creating REST "POST" connections

Note: Replace QlikServer3.domain.local with the name and port of your NPrinting Server

NOTE: replace domain\administrator with the domain and user name of your NPrinting service user account

Ensure to enter the 'Name' Origin and 'Value' of the Qlik Sense (or QlikView) server address in your POST REST connection only.

Replace https://qlikserver1.domain.local with your Qlik sense (or QlikView) server address.

Ensure that the 'Origin' Qlik Sense or QlikView server is added as a 'Trusted Origin' on the NPrinting Server computer

Related Content

• Distribute NPrinting reports after reloading a Qlik App
• Extending Qlik NPrinting
• Run a Qlik NPrinting API POST command via QlikView reload script
• Troubleshooting Common NPrinting API Errors

NOTE: The information in this article is provided as-is and to be used at own discretion. NPrinting API usage requires developer expertise and usage therein is significant customization outside the turnkey NPrinting Web Console functionality. Depending on tool(s) used, customization(s), and/or other factors ongoing, support on the solution below may not be provided by Qlik Support.

The event payloads emitted by the Qlik Cloud webhooks service are changing. Qlik is replacing a legacy event format with a new cloud event format.

Any legacy events (such as anything not already cloud event compliant) will be updated to a temporary hybrid event containing both legacy and cloud event payloads. This will start on or after November 3, 2025.

Please consider updating your integrations to use the new fields once added.

A formal deprecation with at least a 6-month notice will be provided via the Qlik Developer changelog. After that period, hybrid events will be replaced entirely by cloud events.

Webhook automations in Qlik Automate will not be impacted at this time.

Events impacted by this migration

The webhooks service in Qlik Cloud enables you to subscribe to notifications when your Qlik Cloud tenant generates specific events.

At the time of writing, the following legacy events are available:

Any events not listed above will remain as-is, as they already adhere to the cloud event format.

How are events changing

Each event will change to a new structure. The details included in the payloads will remain the same, but some attributes will be available in a different location.

The changes being made:

• All new property names will be lowercase, which may cause some duplication of existing properties within the data object.
• The following properties or objects will be updated:
  • cloudEventsVersion is replaced by specversion. For most events this will be from cloudEventsVersion: 0.1 to specversion: 1.0+.
  • contentType is replaced by datacontentype to describe the media type of the data object.
  • eventId is replaced by id.
  • eventTime is replaced by time.
  • eventTypeVersion is not present in the future schema.
  • eventType is replaced by type.
  • extensions.actor is replaced by authtype and authclaims.
  • extensions.updates is replaced by data._updates
  • extensions.meta, and any other direct objects on extensions are replaced by equivalents in data where relevant.
  • The direct properties of the extensions object will be moved to the root and renamed to be lowercase if needed, such astenantId,userId,spaceId, etc.

Example: Automation created event

This is the current legacy payload of the automation created event:

{
  "cloudEventsVersion": "0.1",
  "source": "com.qlik/automations",
  "contentType": "application/json",
  "eventId": "f4c26f04-18a4-4032-974b-6c7c39a59816",
  "eventTime": "2025-09-01T09:53:17.920Z",
  "eventTypeVersion": "1.0.0",
  "eventType": "com.qlik.v1.automation.created",
  "extensions": {
    "ownerId": "637390ef6541614d3a88d6c3",
    "spaceId": "685a770f2c31b9e482814a4f",
    "tenantId": "BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
    "userId": "637390ef6541614d3a88d6c3"
  },
  "data": {
    "connectorIds": {},
    "containsBillable": null,
    "createdAt": "2025-09-01T09:53:17.000000Z",
    "description": null,
    "endpointIds": {},
    "id": "cae31848-2825-4841-bc88-931be2e3d01a",
    "lastRunAt": null,
    "lastRunStatus": null,
    "name": "hello world",
    "ownerId": "637390ef6541614d3a88d6c3",
    "runMode": "manual",
    "schedules": {},
    "snippetIds": {},
    "spaceId": "685a770f2c31b9e482814a4f",
    "state": "available",
    "tenantId": "BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
    "updatedAt": "2025-09-01T09:53:17.000000Z"
  }
}

This will be the temporary hybrid event for automation created:

{
// cloud event fields
  "id": "f4c26f04-18a4-4032-974b-6c7c39a59816",
  "time": "2025-09-01T09:53:17.920Z",
  "type": "com.qlik.v1.automation.created",
  "userid": "637390ef6541614d3a88d6c3",
  "ownerid": "637390ef6541614d3a88d6c3",
  "tenantid": "BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
  "description": "hello world",
  "datacontenttype": "application/json",
  "specversion": "1.0.2",

// legacy event fields
  "eventId": "f4c26f04-18a4-4032-974b-6c7c39a59816",
  "eventTime": "2025-09-01T09:53:17.920Z",
  "eventType": "com.qlik.v1.automation.created",
  "extensions": {
    "userId": "637390ef6541614d3a88d6c3",
    "spaceId": "685a770f2c31b9e482814a4f",
    "ownerId": "637390ef6541614d3a88d6c3",
    "tenantId": "BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
  },
  "contentType": "application/json",
  "eventTypeVersion": "1.0.0",
  "cloudEventsVersion": "0.1",
  
// unchanged event fields
  "data": {
    "connectorIds": {},
    "containsBillable": null,
    "createdAt": "2025-09-01T09:53:17.000000Z",
    "description": null,
    "endpointIds": {},
    "id": "cae31848-2825-4841-bc88-931be2e3d01a",
    "lastRunAt": null,
    "lastRunStatus": null,
    "name": "hello world",
    "ownerId": "637390ef6541614d3a88d6c3",
    "runMode": "manual",
    "schedules": {},
    "snippetIds": {},
    "spaceId": "685a770f2c31b9e482814a4f",
    "state": "available",
    "tenantId": "BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
    "updatedAt": "2025-09-01T09:53:17.000000Z"
  },
  "source": "com.qlik/automations"
}

Timeline

• November 3, 2025: Hybrid events start emitting (combined legacy and cloud event payloads).
• At least 6 months after a formal deprecation notice: Legacy fields will be removed, leaving fully cloud events only.

Environment

• Qlik Cloud
• Qlik Cloud Government

When querying the /api/v1/apps endpoint in Qlik Cloud Analytics, the results also include Scripts, Data Flows, and Table Recipes.

Is there a way to see only the apps?

Example output:

{                   
  "attributes": {
    "_resourcetype": "app",
    "createdDate": "2025-08-27T06:31:14.767Z",
    "custom": {},
    "description": "",
    "dynamicColor": "",
    "encrypted": true,
    "hasSectionAccess": false,
    "id": "54b3b705-f00f-48ce-bbff-2497926f79e0",
    "isDirectQueryMode": false,
    "lastReloadTime": "",
    "modifiedDate": "2025-08-27T06:31:15.215Z",
    "name": "THIS IS ACTUALLY A TABLE RECIPE",
    "originAppId": "",
    "owner": "auth0|omitted",
    "ownerId": "omitted",
    "publishTime": "",
    "published": false,
    "thumbnail": "",
    "usage": "SINGLE_TABLE_PREP"
  },
  "create": [
    {
      "canCreate": true,
      "resource": "sheet"

...

Resolution

This is working as designed. From the Qlik Cloud Analytics perspective, Scripts, Data Flows, and Table Recipes are considered apps. 

To recognize them, the “usage” attribute needs to be checked:

"usage": “ANALYTICS” → apps
"usage": "SINGLE_TABLE_PREP" → table recipes
"usage": "DATA_PREPARATION" → scripts
"usage": "DATAFLOW_PREP" → data flows

Environment

• Qlik Cloud Analytics

This article explains how the Qlik Sense app button component can be used to send custom parameters directly to the automation without requiring a temporary bookmark. This can be useful when creating a writeback solution on a big app as creating and applying bookmarks could take a bit longer for big apps which adds delays to the solution. More information on the native writeback solution can be found here: How to build a native write back solution.

Contents

• Button configuration
• Automation configuration
• Limitations
• Related Content

Button configuration

1. In this example, we'll use an app that contains car sales opportunities from Salesforce. The straight table, the variable input dropdown, and the native button are important for this example.
   

   
   

2. Start editing the sheet and go to the button configuration section, set the action to "Execute automation" and specify the automation that should run when the button is clicked. If your automation isn't shown, you can copy and paste the automation id.
   
   
   
   
3. Additional input parameters can now be added through the "Add parameter" button.
   
   

   

4. Parameters require a key and a value, it's possible to use Qlik Expressions as input for the value. These expressions are evaluated when the button is clicked.
   
   
   
   
5. After adding the parameters, use the "Copy input block" button to copy the all parameters that will be sent to the automation to your clipboard.
   
   
   
   

Automation configuration

1. If you want anyone who can access the button to be able to run the automation, then set the automation's run mode to "Triggered".

   If you want to limit this to a specific group of users, you can leave the automation in Manual run mode and place it in a shared space that this group of users can access. More information about this is available here: Introducing Automation Sharing and Collaboration. Make sure to disable the Run mode: triggered option in the button configuration.

   
2. Right-click in the automation canvas and select "Paste Block(s)" to add the Inputs block to the automation. Connect the new Inputs block to the Start block. Apart from the default parameters, you'll also find your custom parameters as Inputs in the block.
   
   

   

3. You can now reference the custom parameters from the button in other blocks in the automation by selecting the output from the Inputs block.
   
   
   
   
   

    

Limitations

1. The maximum payload size when triggering an automation is 32kb. When using the GetCurrentSelections expression, every field value will be sent to the automation. This could exceed the 32kb limit. Use the temporary bookmark solution as described in this article instead: Native writeback solutions.
2. Other automation limitations are available here: Platform limitations.
3. More info on configuring the native button can be found here: Creating buttons.

Related Content

• Creating buttons
• Native writeback solutions

Environment

• Qlik Cloud
• Qlik Application Automation

The information in this article is provided as-is and will be used at your discretion. Depending on the tool(s) used, customization(s), and/or other factors, ongoing support on the solution below may not be provided by Qlik Support.

This article provides an overview of how to send straight table data to Microsoft Teams as a table using Qlik Automate.

The template is available on the template picker. You can find it by navigating to Add new -> New automation -> Search templates, searching for 'Send straight table data to Microsoft Teams as a table' in the search bar, and clicking the Use template option.

You will find a version of this automation attached to this article: "Send-straight-table-data-to-Microsoft-Teams-as-a-table.json".

Content:

• Full Automation
• Automation structure
• Related Content

Full Automation

Automation structure

The following steps describe how to build the demo automation: 

1. Add the 'Get Straight Table Data' block from the Qlik Cloud Services connector to get data from the straight table for a specific app to send to the Microsoft Teams channel as a table. Specify the app ID, Sheet ID, and Object ID in the input parameters. You can use the do-lookup functionality to find value for all these parameters. There is a limit of 100,000 records that can be retrieved through the 'Get Straight Table Data' block. This block will not work with other table types.
   
   
2. Add a 'Loop' block to loop over the keys from the 'Get Straight Table Data' block response which acts as the table header. Use the '{getkeys: {$.GetStraightTableData}}' formula in the 'Loop' block. Within the 'Loop' block add the following blocks:
   
   
   1. Add an object variable called 'teamsTextBlockObject' to build the header and pass this variable to another list variable called 'cardTableColumn'.
      
      
   2. Add another 'Loop' block to loop over all the values for the current key of the straight table. Within the 'Loop' block add the following blocks:
      
      
      1. Add a 'Condition' block to check whether the column value is empty or not.
         
         
         • If the condition block outcome evaluates to true:
           
           
           • Add the 'teamsTextBlockObject' object variable, set the text value as 'NA' since the column value is null/empty, and pass this variable to the 'cardTableColumn' list variable.
             
             
         • If the condition block outcome evaluates to false:
           
           
           • Add the 'teamsTextBlockObject' object variable, set the text value as the column value of the straight table, and pass this variable to the 'cardTableColumn' list variable.
             
             
   3. Add another object variable called 'columnObject' and pass this variable to the 'columns' list variable. These variables are used to build the straight table data into a specific format which is required to build the structure of the team's message as a card attachment.
      
      
3. Add a string variable called 'title' which is used to provide the title to the message.
   
   
4. Add the 'Create Attachment Adaptive Card' block from the Microsoft Teams connector to build the structure for card attachment. Make sure to transform the 'columns' list to JSON text using the JSON formula.
   
   
   
   
5. Add 'Send Message' block from the Microsoft Teams connector to send straight table data as a table to the Teams channel with the card attachment which was created in the previous block.
   Specify the Team ID and the Channel ID in the input parameters. You can use the do-lookup functionality to find the value of all these parameters. 
   
   
   

An example output of the table sent to the Teams channel:

The information in this article is provided as-is and will be used at your discretion. Depending on the tool(s) used, customization(s), and/or other factors, ongoing support on the solution below may not be provided by Qlik Support.

Related Content

• How to get started with Microsoft Teams
• Send straight table data to Microsoft Teams as a message 
• Send straight table data to email as HTML table

Environment

• Qlik Cloud Analytics
• Qlik Automate

This article provides an overview of how to send straight table data to email as an HTML table using Qlik Automate.

The template is available on the template picker. You can find it by navigating to Add new -> New automation -> Search templates and searching for 'Send straight table data to email as table' in the search bar, and clicking the Use template option.

You will find a version of this automation attached to this article: "Send-straight-table-data-to-email -as-HTML-table.json".

Content:

• Full Automation
• Automation structure
• Related Content

Full Automation

Automation structure

The following steps describe how to build the demo automation: 

1. Add a variable called 'EmailBody' to build the email body, and append the body opening tag and opening text of the email as value to this variable.
   
   
2. Add another variable called 'EmailStraightTable' and append the table opening tag together with the table header opening tag as a value to this variable.
   
   
3. Use the 'Get Straight Table Data' block from the Qlik Cloud Services connector to get data from the straight table for a specific app to be sent as an email. Specify app ID, Sheet ID, and Object ID input parameters. You can use the do-lookup functionality to find value for all these parameters. There is a limit of 100,000 records that can be retrieved through the 'Get Straight Table Data' block. This block will not work with other table types.
   
   
4. Add a 'Loop' block to loop over the keys from the 'Get Straight Table Data' block response which act as the headers of the HTML table. Use the '{getkeys: {$.GetStraightTableData}}' formula in the 'Loop' block.
   
   
5. Add the key/column name as the header of the HTML table in the 'EmailStraightTable' variable block. Outside the loop, add the 'EmailStraightTable' variable block, and append the table header closing tag, and table body opening tag as values to this variable.
   
   
6. Add a 'Loop' block to loop over all the values from the 'Get Straight Table Data' block response. Within the 'Loop' block add the following blocks:
   
   
   1. Use the 'EmailStraightTable' variable block and append the table row opening tag as a value to this variable.
   2. Use another 'Loop' block to loop over all values from the straight table for the current key/ column of the straight table.
   3. Next, use the 'EmailStraightTable' variable block and append the table data opening tag along with the column value for the corresponding key from the straight table which ultimately gives a single row with values for all the keys in each iteration and the table data closing tag as value to this variable.
   4. Use the 'EmailStraightTable' variable block and append the table row closing tag as a value to this variable.
      
      
7. Add the 'EmailStraightTable' variable block and append the table body closing tag with table footer tags as a value to this variable.
   
   
8. Add the 'EmailBody' variable block and append the 'EmailStraightTable' variable, which contains the final HTML table with straight table data, together with the email footer, and body closing tag as a value to this variable.
   
   
9. Add a 'Send Mail' block from the Mail connector to send an email with the above constructed HTML table that contains straight table data. Specify values for all the mandatory input parameters. Please connect to the SMTP server by adding a connection to the Mail connector.

An example output of the email sent:

The information in this article is provided as-is and will be used at your discretion. Depending on the tool(s) used, customization(s)andor other factors, ongoing support on the solution below may not be provided by Qlik Support.

Related Content

How to export more than 100k cells using Get Straight Table Data Block 

Environment

• Qlik Cloud Analytics
• Qlik Automate

This article provides an overview to get started with the OpenAI connector in Qlik Automate. 

The OpenAI connector offers developers a range of powerful natural language processing capabilities. It allows for tasks such as text generation, translating between languages, analyzing sentiment, summarizing content, and building question-answering systems. These features enable you to bring additional value to your existing automations.

Content:

• Authentication
• Working with OpenAI blocks
• Use cases
• Tips and limitations
• A Deep Dive into Create Completion Block

Authentication

Create a new automation and search for the OpenAI connector in the block library on the left side. Drag a block inside the automation editor canvas, and make sure to select the block to show the block configuration menu on the right side of the editor. Open the Connect tab in the configuration menu and provide your OpenAI API key. Visit your API Keys page to retrieve the API key you'll use in your requests.

Working with OpenAI blocks 

Once the connection to your OpenAI account has been created, you can start building an automation that uses the connector. 

The available blocks are:

• List Models: This block returns a list of available models, including their names, descriptions, and capabilities.
• Retrieve Model: This block returns detailed information about a specific model, including its parameters, training data, and performance metrics.
• Create Completion: This block generates text using a model. The request body includes the prompt, parameters. The response body includes the generated text. More information about each parameter in this block can be found at the end of this article.
• Raw API Request: This block allows you to make a generic request to the OpenAI API and allows you to configure the HTTP method and query or body parameters.
• Raw API List Request: This block lets you perform a generic GET request to the OpenAI API and returns the results as a list over which you can loop.

For more details on the API, please refer to the following link.

At the time of writing this article, the Images and Audio endpoints in the OpenAI API are in beta state but can be used through the Raw API Request blocks.

Use cases

Sentiment analysis and response suggestions for incidents in ServiceNow

This use case is based on the existing template "Analyze support ticket sentiment with Expert.ai". In this template, Expert.ai is used to predict the sentiment of new support tickets from ServiceNow. If the sentiment is deemed too negative, the automation will send an alert to a Microsoft Teams channel to inform the support team about the incident. For convenience, we'll leave out the write to MySQL and app reload part of the original template.

If you want, you could also use OpenAI to predict the sentiment instead of Expert.ai. But keep in mind that this could provide a less accurate result since the Expert.ai.

1. Go to your Qlik Sense tenant and create a new automation.
2. Search for the ServiceNow connector and drag the List New And Updated Incidents Incrementally block in the automation. When this block is executed for the first time, it will retrieve all incident records from ServiceNow. It will also set a pointer with the DateTime of its last execution. On the next executions, the block will only retrieve incidents that were created or updated after the pointer and it will update the pointer. Go to the block's Connection tab and connect your ServiceNow account.
   
    

   

3. Search for the Expert.ai connector and drag the Run Analysis Task block inside the loop. Go to the block's Connection tab and connect your Expert.ai account. Then go to the Inputs tab to further configure the block. Set Analyze Type to "Sentiment analysis" and set the language to "en" for English. Feel free to configure this to another language depending on your support portal. Finally, configure the Document Text parameter to the Description key of the current item in the loop from the List New And updated Incidents Incrementally block.
   
   
   

   

4. We want to make a distinction between positive and negative sentiment. Add a Condition block to the automation and configure the overall sentiment (returned by Expert.ai) as the first argument and compare it to a threshold of your choosing, in this example, we're using -10 as the lower threshold for "very" negative sentiment. Note: the threshold needs to be a number between -100 (negative) and 100 (positive).
   

   
   

5. Add the Create Completion block from the OpenAI connector as the first block in the Yes part of the Condition block. Configure the inputs as follows:
   1. Model: text-davinci-003
   2. Prompt: Write a possible reply a support engineer could write for the below support case. Then add a linebreak and map the description from the ServiceNow incident.
      

      
      

6. Search for the Update Incident block in the ServiceNow connector, this will write back the sentiment to the incident in ServiceNow. Add it to the automation twice. (One block for every outcome of the Condition block). Instead of immediately writing the suggested response as a reply to the customer who logged the incident, add it as an internal "work note" to the incident. For this example, we've added 2 custom fields to the Incident object in ServiceNow, one to store the overall sentiment and one boolean (Yes/No) that indicates if the incident has a sentiment lower than our threshold. More information on custom fields in ServiceNow can be found here.
   
   
   
    
7. As a next step, you could include alerting functionality to make your support team aware of the ticket with a negative sentiment below a certain threshold. In this example, we'll send an alert to a channel in Microsoft Teams. Search for the Microsoft Teams connector and add the Send Message block in the 'Yes' part of the condition block. Tip, use the left trim formula on the output from the Create Completion block to remove any leading linebreaks "\n".
   

   
   

8. Result in Microsoft Teams:
   

   
   
   
   

Tips and limitations

Below are a couple of tips and limitations to keep in mind when working with the OpenAI connector in automations.

1. If the usage quota is exceeded with the Free OpenAI account, the following error message will be displayed. Upgrading to a paid OpenAI account will resolve the issue.
   

   {
       "error": {
           "message": "You exceeded your current quota, please check your plan and billing details.",
           "type": "insufficient_quota",
           "param": null,
           "code": null
       }
   }​

2.  For an overview of the rate limitations in the OpenAI API, please refer to this documentation.
3. Raw API Request block: This connector does not support the OpenAI API with the content type Multipart/form-data. Following API are not supported in Raw API Request block
   1. Upload file.
   2. Create image edit.
   3. Create image variation.
   4. Create transcription.
   5. Create translation.
4. No paging for list blocks: Since the OpenAI API has no support for paging, all records a list block in an automation retrieves are returned in a single API response by OpenAI. The List Models and the Raw API List Request blocks are examples of list blocks.

A Deep Dive into Create Completion Block

Create completion block: The model parameter, the only required parameter in this block, allows us to produce a random answer. A minimum prerequisite for a more insightful response is a model, prompt, and Max Tokens input parameter. Other input variables may be employed to narrow down the response.

1. Model: This is the only required parameter in this block that specifies which model to use for generating completions. You can use the List models API to see all available models or see OpenAI's Model overview for their descriptions.
   
   Example value: "text-davinci-003"
   
   
2. Prompt: The prompt(s) to generate completions for, encoded as a string, array of strings, array of tokens, or array of token arrays. The <|endoftext|> token can be used in a prompt to indicate the end of the first section of the prompt, which is the introduction. The second section of the prompt would then be the body of the poem.
   
   Prompt:

   Write a summary of the following data.
   <|endoftext|>
   Country | Population
   ------- | --------
   United States | 329.5 million
   China | 1.444 billion
   India | 1.38 billion 

   Completion:

   This data shows the population of three of the largest countries in the world. The United States has a population of 329.5 million, China has a population of 1.444 billion, and India has a population of 1.38 billion. 

    

3. Max Tokens: Specifies the maximum number of tokens in the generated completion response. More information about how the token count is calculated by OpenAI can be found here: Tokenizer.

   Example: 50

The following parameters are optional in most use cases but could be used to fine-tune the response:

1. Temperature: Controls the randomness of the output. Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more focused and deterministic.
   
   • Example: 0.6
2. Top p: Controls the diversity of the generated output by setting a probability threshold. top_p (or nucleus) selects the most likely tokens until the cumulative probability exceeds the threshold. 
   
   • Example:0.8
3. Number Of Completions: Specifies the number of completions to generate.
   
   • Example: 3
4. Logprobs: Specifies whether to include the log probabilities for each token in the response.
   
   • Example: 2
5. Presence Penalty: Adjusts the model's likelihood of generating repetitive phrases. Higher values (e.g., 0.8) make the output more focused and deterministic, while lower values (e.g., 0.2) make it more creative.
   
   • Example: 0.6
6. Frequency Penalty: Adjusts the model's likelihood of generating uncommon phrases. Higher values (e.g., 0.8) make the output more focused and deterministic, while lower values (e.g., 0.2) make it more creative.
   • Example: 0.4
7. Best Of: Specifies the number of completions to generate and return. The API will randomly select the best one among them.
   • Example: 5
8. Logit Bias: The `logit bias` parameter in the OpenAI API enables you to prioritize certain tokens over others when generating text. For instance, by assigning a higher bias to "cat" (e.g., 3.0) and lower biases to other tokens like "dog" (e.g., 1.5) and "bird" (e.g., -2.0), you can influence the model to generate more content related to cats.
   
   Example:
   
   {
   "cat": 3.0,
   "dog": 1.5,
   "bird": -2.0
   }
   
   
9. User: Specifies an optional user ID or string that can be used to customize the model's behavior based on the user.
   • Example: "12345"

This capability has been rolled out across regions over time:

1. May 5th: India, Japan, Middle East, Sweden (completed)
2. June 4th: Asia Pacific, Germany, United Kingdom, Singapore (completed)
3. June 9th: United States (completed)
4. June 12th: Europe (completed)
5. June 26th: Qlik Cloud Government

With the introduction of shared automations, it is now possible to create, run, and manage automations in shared spaces. 

Content

• Allow other users to run an automation
• Collaborate on existing automations
• Collaborate through duplication
• Extended context menus
• Context menu for owners:
• Context menu for non-owners:
• Monitoring
• Administration Center
• Activity Center
• Run history details
• Metrics

Allow other users to run an automation

Limit the execution of an automation to specific users.

Every automation has an owner. When an automation runs, it will always run using the automation connections configured by the owner. Any Qlik connectors that are used will use the owner's Qlik account. This guarantees that the execution happens as the owner intended it to happen.

The user who created the run, along with the automation's owner at run time, are both logged in the automation run history.

These are five options on how to run an automation:

1. Run an automation from the Hub and Catalog
   
   
   
   
2. Run an automation from the Automations activity center
   
   

    

3. Run an automation through a button in an app
   
   You can now allow other users to run an automation through the Button object in an app without needing the automation to be configured in Triggered run mode. This allows you to limit the users who can execute the automation to members of the automation's space.
   
   More information about using the Button object in an app to trigger automation can be found in How to run an automation with custom parameters through the Qlik Sense button.
   
   
4. Programmatic executions of an automation
   
   
   1. Automations API: Members of a shared space will be able to run the automations over the /runs endpoint if they have sufficient permissions.
   2. Run Automation and Call Automation blocks
      
      
5. Note for triggered automations: the user who creates the run is not logged as no user specific information is used to start the run. The authentication to run a triggered automation depends on the Execution Token only.

Collaborate on existing automations

Collaborate on an automation through duplication.

Automations are used to orchestrate various tasks; from Qlik use cases like reload task chaining, app versioning, or tenant management, to action-oriented use cases like updating opportunities in your CRM, managing supply chain operations, or managing warehouse inventories.

Collaborate through duplication

To prevent users from editing these live automations, we're putting forward a collaborate through duplication approach. This makes it impossible for non-owners to change an automation that can negatively impact operations.

When a user duplicates an existing automation, they will become the owner of the duplicate. This means the new owner's Qlik account will be used for any Qlik connectors, so they must have sufficient permissions to access the resources used by the automation. They will also need permissions to use the automation connections required in any third-party blocks. 

Automations can be duplicated through the context menu:

As it is not possible to display a preview of the automation blocks before duplication, please use the automation's description to provide a clear summary of the purpose of the automation:

Extended context menus

• Start a run from the context menu in the hub
• Duplicate automation
• Move automation to shared space
• Edit details (owners only)
• Open in new tab (owners only)

Context menu for owners:

 

Context menu for non-owners:

 

 

Monitoring

The Automations Activity Centers have been expanded with information about the space in which an automation lives. The Run page now also tracks which user created a run.

Note: Triggered automation runs will be displayed as if the owner created them.

Administration Center

The Automations view in Administration Center now includes the Space field and filter.

The Runs view in Administration Center now includes the Executed by and Space at runtime fields and filters.

Activity Center

The Automations view in Automations Activity Center now includes Space field and filter.

Note: Users can configure which columns are displayed here.

The Runs view in the Automations Activity Center now includes the Space at runtime, Executed by, and Owner fields and filters.

In this view, you can see all runs from automations you own as well as runs executed by other users. You can also see runs of other users's automations where you are the executor.

Run history details

To see the full details of an automation run, go to Run History through the automation's context menu. This is also accessible to non-owners with sufficient permissions in the space.

The run history view will show the automation's runs across users, and the user who created the run is indicated by the Executed by field.

Metrics

The metrics tab in the automations activity center has been deprecated in favor of the automations usage app which gives a more detailed view of automation consumption.

Content:

• Step-by-Step:
• Limitations
• Related Content

Step-by-Step:

To create a Mail connection in Qlik Automate, do the following:

1. In Qlik Cloud Hub, create a new Automation
   
   
2. In the Edit Dialogue, locate Mail
   
   
   
   
   
3. Drag the Send Mail (A) block onto the canvas
   
   
4. Click Connection (B) and Create Mail connection (C) to set up a new Mail connection; alternatively, choose an existing connection
   
   
   
   
5. In the Input pane, fill out the required fields to send a test email
   
   
   
   
6. Press Save and Run to execute the automation
   
   
7. Verify that the test email is being sent successfully and received in the mailbox
   
   If you receive any error when running the test automation, verify the details of your SMTP server are correct (Host, Password still accurate, Port etc):
   
   
   
   
8. In the menu select Connections to go back to the connections page
9. In My connections, select the Mail connection and press Edit connection
10. Confirm all settings being correct and press Save
11. Run the test automation again to confirm the email being sent

Limitations

• The Mail Connector does not at present support SSO. See Qlik Application Automation: "Send Mail" block doesn't work with Gmail's with Okta integration
  
  
• The configuration for an Email server that already exists on a tenant cannot be used within an automation. A new connection must be created in Qlik Automate.
  
  
  
  
• The connection will not be verified during creation. As a best practice it is always recommended to verify the Mail connection with a simple automation, before using the Send Mail block in more advanced automations.

Related Content 

The information in this article is provided as-is and to be used at own discretion. Depending on tool(s) used, customization(s), and/or other factors ongoing support on the solution below may not be provided by Qlik Support.

Installing, upgrading, and managing the Qlik Cloud Monitoring Apps has just gotten a whole lot easier! With two new Qlik Application Automation templates coupled with Qlik Data Alerts, you can now: 

1. Install/update the apps with a fully guided, click-through installer using an out-of-the-box Qlik Application Automation template. 
2. Programmatically rotate the API key required for the data connection on a schedule using an out-of-the-box Qlik Application Automation template. This ensures the data connection is always operational. 
3. Get alerted whenever a new version of a monitoring app is available using Qlik Data Alerts. Repeat Step 1 to complete the update. 

The above allows you to deploy the monitoring apps to your tenant with a hands-off approach. Dive into the individual components below. 

Some monitoring apps are designed for specific Qlik Cloud subscription types. Refer to the compatibility matrix within the Qlik Cloud Monitoring Apps repository.

Content:

• Part One: 'Qlik Cloud Monitoring Apps Installer' template overview
• Part Two: 'Qlik Cloud Monitoring Apps API Key Rotator' template overview
• Part Three: How to setup a Qlik Alert to know when an app is out of date
• A Qlik Cloud Monitoring Apps Workflow Demo (Video)
• FAQ

Part One: 'Qlik Cloud Monitoring Apps Installer' template overview

This automation template is a fully guided installer/updater for the Qlik Cloud Monitoring Applications, including but not limited to the App Analyzer, Entitlement Analyzer, Reload Analyzer, and Access Evaluator applications. Leverage this automation template to quickly and easily install and update these or a subset of these applications with all their dependencies. The applications themselves are community-supported; and, they are provided through Qlik's Open-Source Software GitHub and thus are subject to Qlik's open-source guidelines and policies.

For more information, refer to the GitHub repository.

Features

• Can install/upgrade all or select apps.
• Can create or leverage existing spaces.
• Programmatically handles pre-requisite settings, roles, and entitlements.
• Installs latest versions from Qlik’s OSS GitHub.
• Creates required API key.
• Creates required analytics data connection.
• Can create custom reload schedules.
• Can reload post-install.
• Tags apps appropriately to track which are installed and their respective versions.
• Supports both user and capacity-based subscriptions

Click-through installer:

Flow:

Note that if the monitoring applications have been installed manually (i.e., not through this automation) then they will not be detected as existing. The automation will install new copies side-by-side. Any subsequent executions of the automation will detect the newly installed monitoring applications and check their versions, etc. This is due to the fact that the applications are tagged with "QCMA - {appName}" and "QCMA - {version}" during the installation process through the automation. Manually installed applications will not have these tags and therefore will not be detected.

 

Part Two: 'Qlik Cloud Monitoring Apps API Key Rotator' template overview

This template is intended to be used alongside the Qlik Cloud Monitoring Apps for user-based subscriptions template. This automation provides the ability to keep the API key and associated data connection used for the Qlik Cloud Monitoring Apps up to date on a scheduled basis. Simply input the space Id where the monitoring_apps_REST data connection should reside, and the automation will recreate both the API key and data connection regularly. Ensure that the cadence of the automation’s schedule is less than the expiry of the API key.

Configuration

Enter in the Id of the space where the monitoring_apps_REST data connection should reside.

Ensure that this automation is run off-hours from your scheduled monitoring application reloads so it does not disrupt the reload process.

Part Three: How to setup a Qlik Alert to know when an app is out of date

Each Qlik Cloud Monitoring App has the following two variables:

• vLatestVersion: the latest version of the app released on Qlik’s OSS GitHub.
• vIsLatestVersion: a Boolean of whether the app’s current version is equal to the latest version of the app released on Qlik’s OSS GitHub (1 if true, 0 if false).

With these variables, we can create a new Qlik Data Alert on a per-app basis. For each monitoring app that you want to be notified on if it falls out of date:

1. Right-click on a chart in the app, select Alerts and then Create new alert.
2. Clear out the defaults and provide the alert with a name such as <Monitoring App Name> is Out of Date.
3. Select Add measure and select the fx icon to enter a custom expression. Enter the expression ’$(vLatestVersion)'. Ensure it is wrapped in single quotes, then provide the label for the expression Latest Version.
4. Select Add measure and select the fx icon to enter a custom expression. Enter the expression $(vIsLatestVersion), then provide the label for the expression Is Latest Version.
5. Confirm the Details & data tab resembles the following:
   
   
   
   
6. Navigate to the next tab, Conditions.
7. Set the Measure to Is Latest Version, the Operator to Equal to, and the Value to 0. This way, if the app is not the latest version (0), it will trigger the alert.
8. Confirm that the Conditions tab resembles the following:
   
   
   
   
9. Navigate to the Distribution tab and confirm that the alert is evaluated When data is refreshed.

Here is an example of an alert received for the App Analyzer, showing that at this point in time, the latest version of the application is 5.1.3 and that the app is out of date:

A Qlik Cloud Monitoring Apps Workflow Demo (Video)

FAQ

Q: Can I re-run the installer to check if any of the monitoring applications are able to be upgraded to a later version?

A: Yes. Run the installer, select which applications should be checked and select the space that they reside in. If any of the selected applications are not installed or are upgradeable, a prompt will appear to continue to install/upgrade for the relevant applications.

Q: What if multiple people install monitoring applications in different spaces?

A: The template scopes the applications install process to a “target” space, i.e., a shared space (if not published) or a managed space. It will scope the API key name to `QCMA – {spaceId}` of that target space. This allows the template to install/update the monitoring applications across spaces and across users. If one user installs an application to “Space A” and then another user installs a different monitoring application to “Space A”, the template will see that a data connection and associated API key (in this case from another user) exists for that space already and it will install the application leveraging those pre-existing assets.

Q: What if a new monitoring application is released? Will the template provide the ability to install that application as well?

A: Yes. The template receives the list of applications dynamically from GitHub. If a new monitoring application is released, it will become available immediately through the template.

Q: I would like to be notified whenever a new version of a monitoring applications is released. Can this template do that?

A: As per the article above, the automation templates are not responsible for notifications of whether the applications are out of date. This is achieved using Qlik Alerting on a per-application basis as described in Part 3.

Q:I have updated my application, but I noticed that it did not preserve the history. Why is that?

A: The history is preserved in the prior versions of the application’s QVDs so the data is never deleted and can be loaded into the older version. Each upgrade will generate a new set of QVDs as the data models for the applications sometimes change due to bug fixes, updates, new features, etc. If you want to preserve the history when updating, the application can be upgraded with the “Publish side-by-side” method so that the older version of the application will remain as an archival application. However note that the Qlik Alert (from Part 3) will need to be recreated and any community content that was created on the older application will not be transferred to the new application.

This article describes how to resolve the NPrinting connection verification error:

x Qlik NPrinting webrenderer can reach Qlik Sense hub error

Environment

• NPrinting: all versions
• Qlik Sense: all versions
  • multi-node QS proxy environment
  • NLB (Network Load Balancer or Alias URL) server address used in front of cluster of Qlik Sense proxy nodes (which are linked to a Virtual Proxy. Proxy nodes will not work with NPrinting unless they are linked to a QS virtual proxy)

Resolution

• Although it is possible to use an NLB address in front of your QS proxy nodes that are used by NPrinting, the error generated in the NP connection verification process will appear as described in the article title
• This error can safely be ignored as this does not affect generation of NPrinting connections
• To eliminate the 'error' message, you would need to update your NPrinting connection to use a virtual proxy node address/computer name behind the NLB address . It must be the computer name and not an alias url).
• The proxy node used must be linked to a virtual proxy with the following required attribute
  
  • Microsoft Windows NTML authentication on the Qlik Sense proxy. (SAML and JWT are not supported. If your virtual proxy uses SAML or JWT authentication, you need to add a new virtual proxy with NTLM enabled for Qlik NPrinting connections).
  • A link between the proxy node and virtual proxy.
  • For all NPrinting to Qlik Sense requirements visit https://help.qlik.com/en-US/nprinting/Content/NPrinting/DeployingQVNprinting/NPrinting-with-Sense.htm#anchor-1
• If a DNS name is involved and the Qlik Sense certificates are generated using that DNS name, try disabling the "Apply Qlik Sense server certificate validation" checkbox.

Related Content

• https://help.qlik.com/en-US/nprinting/Content/NPrinting/Troubleshooting/Verify-connection-to-Sense-errors.htm
• https://help.qlik.com/en-US/nprinting/Content/NPrinting/DeployingQVNprinting/NPrinting-with-Sense.htm#Requirem

Internal Investigation ID

• QB-2871
• QB-25870

This article is intended to get started with the Microsoft Outlook 365 connector in Qlik Application Automation.

Authentication and Authorization

To authenticate with Microsoft Outlook 365 you create a new connection. The connector makes use of OAuth2 for authentication and authorization purposes. You will be prompted with a popup screen to consent a list of permissions for Qlik Application Automation to use. The Oauth scopes that are requested are:

• Mail.Send
• User.Read
• Offline_access

Sending Email with the Microsoft Outlook 365 connector

The scope of this connector has been limited to only sending emails. Currently, we do not enable sending email attachments and are looking to provide this functionality in the future. The suggested approach is to upload files to a different platform, e.g. Onedrive or Dropbox and create a sharing link that can be included in the email body.

The following parameters are available on the Send Email block:

• To: A comma separated list of recipients;
• CC: A comma separated list of recipients to which the email should be copied;
• BCC: A comma separated list of recipients to which the email should be blind copied;
• Subject: A title for your email;
• Type: Choose between plain text email or HTML;
• Body: The content of your email. You can use HTML for your email if chosen as the type.

Generating a report and sending an email with the report

As we do not currently support email attachments, we need to first generate a sharing link in Onedrive or an alternative file sharing service. The following automation shows how to generate a report from a Qlik Sense app, upload the report to Microsoft Onedrive, create a sharing link and send out an email with the sharing link in the body. This automation is also attached as JSON in the attachment to this post.

Environment:

Qlik Automate 

Using Qlik-CLI to export an app without the '--exportScope all' parameter fails with the error:

Error: 400 - Bad Request - Qlik Sense

This is observed after an upgrade to Qlik Sense Enterprise on Windows November 2024 patch 10 or any later version. The error is intermittent and the export may succeed if executed several times.

Reviewing the output shows Status: 201 Created, followed by the error after retrieving the app from the temporary download path:

> qlik qrs app export create "dbb1841d-f3f6-4a49-b73f-0a24cc003b1b" --exportScope all --output-file "C:/temp/App3.qvf" --insecure --verbose
Insecure flag set, server certificate will not be verified
POST https://sense/jwt/qrs/app/dbb1841d-f3f6-4a49-b73f-0a24cc003b1b/export/e237e6c8-d367-45d3-9eff-9f191b3f1ef5?exportScope=all&xrfKey=4B21426C21AE6B85...
Status: 201 Created
{
"exportToken": "e237e6c8-d367-45d3-9eff-9f191b3f1ef5",
"appId": "dbb1841d-f3f6-4a49-b73f-0a24cc003b1b",
"downloadPath": "/tempcontent/f8deec7c-5ab4-4462-879b-38990febbd1b/Test.qvf?serverNodeId=ae6a7f27-1abd-439e-b4da-0a0b0f4a3e61",...
}
GET https://sense/jwt/tempcontent/f8deec7c-5ab4-4462-879b-38990febbd1b/Test.qvf?serverNodeId=ae6a7f27-1abd-439e-b4da-0a0b0f4a3e61&xrfKey=4B21426C21AE6B85...
Status: 400 Bad Request
400 - Bad Request - Qlik Sense
Error: 400 - Bad Request - Qlik Sense

Resolution

This is being investigated by Qlik as SUPPORT-3800.

Workaround

Delete the content of the cookie store ( ~/.qlik/.cookiestore) when the error occurs.

In Windows, this can be found in %USERPROFILE%\.qlik\.cookiestore

A batch job can be created to automate the deletion.

Cause

This is caused by an incorrect cookie handling by Qlik-CLI. While exporting the app, the responses include the Set-Cookie header, but qlik-cli fails to update the cookie store with the new cookie.

Environment

• Qlik Sense Enterprise on Windows

A user can enable failure notifications for automations in their profile settings. Reference: Notifications

However, if the user is not the owner of an automation hosted in a shared space, they will not receive the expected notification.

Only the automation owner will be alerted.

This behaviour is different than the one for application reloads, where tenant admins and people with permissions on a shared space can also be notified.

Resolution

This is a current limitation.

To provide Qlik with input on this limitation and suggest changes, head to Qlik's ideation portal, which our product teams actively monitor.

Environment

• Qlik Automate
• Qlik Cloud

A user can enable failure notifications for automations in their profile settings. Reference: Notifications

However, despite the automation failing several times, only the original notification of the first failure is delivered.

Resolution

This is as designed.

Since automations can be run every 30 seconds, we want to avoid spamming the user with notifications. We therefore have a 6-hour window after a failure during which the user will not receive another alert.

Another can be sent after six hours. 

Qlik plans to reduce the window from 6 hours to 1 hour. No estimated time for this change is known yet.

Environment

• Qlik Automate
• Qlik Cloud

With the release of shared automations in Qlik Automate, it is now possible to run an automation in a Shared Space for users other than the owner. The automation will run using the owner’s Qlik account and any third-party connections as they were configured by the owner.

When an automation is run by another user, it is possible to retrieve this user’s information during the automation run. This article outlines how this is done.

This is only supported when the automation is run from the console or API. It is not supported for triggered automations when they are run from the trigger URL or webhook automations when they are run from the webhook event. The reason for this is that in these cases, no user subject is sent to the automation (triggered executions use the execution token instead of a user token, and webhook automations have no user involved when they are run by the webhook event).

However, if triggered or webhook automations are run manually or over API, it will be possible to retrieve the user's info.

Identifying the user who started the Automation

When an automation is run by any user, it is possible to retrieve the user id and user info for the user who executed the automation during the automation run.

1. Use the Get Automation Run block (A) from the Qlik Cloud Services connector and configure it with the Automation ID and Automation Run ID (C) formulas from the formula picker (B).
   
   
   
   
   
   
   
   
2. The Get Automation Run block will return the executedByID to identify who has started the automation:
   
   
   
   
3. Configure the Get User block to use the executedById parameter as input for the User Id parameter:
   
   
   
   
   
   
4. You can then use a Condition block to evaluate the returned value from the Get User block.
   
   For example, you can check if the user is a part of a predefined list of users:
   
   
   
   
   
   

Environment

• Qlik Cloud Automate
• Qlik Cloud

Currently, in Qlik Application Automation it is not possible to export more than 100,000 cells using the Get Straight Table Data block.

Content:

• Full Automation
• Steps to set up the variables
• Automation structure

To overcome this limit, the workaround is to export records in batches from the Qlik Sense straight table to the cloud storage platform of your choice. The prerequisite is to have a unique numerical field in your dataset. If you don't have the unique field in your dataset, you can add it using RowNo() function in the load script as shown below. This counts the rows in the dataset.

In this example, we will export data from the Qlik Sense straight table to Dropbox as a CSV file.

You can also find an exported version of this automation and application attached to this article. More information on importing automation can be found here.

Full Automation

Automation Part 1

Automation Part 2

Automation Part 3

Steps to set up the variables

1. vAppId: Variable used to define your app ID.
2. vSheetId: Variable used to define your sheet ID.
3. vTableId: Variable used to define your straight table ID.
4. vFieldName: Variable used to define the field name on which the straight table data should be filtered based on the selection applied using the Select Field Value By Query block.

Automation structure

1. Add the Create Measure block to the automation and configure the Measure Expression parameter by providing an expression that calculates the number of rows in the dataset. In this example, I have added RowNo( ) as a unique field to the dataset, so the expression used is count([RowNo( )]).
2. Add the Get Measure block to get the number of rows in the dataset.
3. Store the number of rows obtained from the previous step in the vNRecords variable.
4. Delete the measure created using the Delete Measure block.
5. Add the vNLoops variable to calculate the number of loops that can be used to export straight table data in batches. Please note the formula used in the variable. Edit it to suit your needs. Change the 10000 value as you want but keep in mind that too many records could exceed the Get Straight Table Data block's 100,000 cells limit.
   
   
   
   
6. The Custom Code block creates a list with items 1 to n where n is the number of loops calculated in the previous step.
7. Add Create File on Dropbox block to create a new CSV file in Dropbox. You can select any other cloud storage connector, just remember to configure the relevant value in the Path parameter. The Qlik Sense straight table data will be exported to this file.
8. Add the Select Field Values By Query block to apply selection to the unique identifier created in the dataset to fetch only one record from the Get Straight Table Data block.
9. Add Write Line To File on Dropbox block to add straight table keys as column headers to the CSV file.
10. Add Loop block to loop over the list created using the Custom Code block.
11. Add Condition block to check if it's iterating over the 1st item, if yes set vRecordsStart variable value to 1, else set vRecordsStart variable value to vRecordsEnd variable. The vRecordsEnd variable represents the last record that needs to be fetched from the straight table during each iteration. Please note the formula used in the variable. The value under the Value 1 parameter in the Multiply formula should match the value provided in the Divide formula of the vNLoops variable.
    
    
    
    
12. Add the Select Field Values By Query block to apply selection to the unique identifier created in the dataset to fetch the records between vRecordsStart and vRecordsEnd variables from the Get Straight Table Data block.
13. Add Write Line To File on Dropbox block within the Get Straight Table Data block which writes each straight table data into the CSV file. Configure it to use the output from the Get Straight Table Data block as the Data parameter.
14. Add Save And Close File on Dropbox block and configure the file parameter to use the CSV file we have created.

Environment

• Qlik Cloud
• Qlik Automate 

An OAuth client has admin.apps, admin.automations and admin.spaces scopes.

When using it with API calls to run automations in a shared space, the result is 403 insufficient permissions.

The assumption is that the admin scopes should be enough to execute the automation.

Resolution

Explicitly add the OAuth client as a user on the tenant and give the user Can manage permissions. 

Cause

It is the same concept as a Tenant Admin.

A Tenant Admin can see everything, but to open apps in a space or reload them, the admin user must be explicitly added to the space.

The same concept applies to the OAuth admin scopes.

Environment

• Qlik Automate
• Qlik Cloud

This article documents how to create an AWS Amazon DynamoDB table using Qlik Automate. The example automation is attached to this article and can be imported. See How to import and export automations for details.

1. Choose the Amazon DynamoDB Create Table block
   
   
   
   The Key Schema and Attribute Definitions input field cannot simply have a JSON structure applied (such as "[{'AttributeName': 'ID', 'KeyType': 'HASH'}]"). The key is to create variables and lists and apply these lists as inputs.
   
   
   • Key Schema example:
     
     First, create an AttributeName variable with the Key AttributeName and the Value ID
     
     
     
     
   • Repeat this for the KeyType variable with the Key KeyType and Value HASH.
     
     
     
     
2. Create a Variable List with the Variable keyList (list) and Item Key
   
   
   
   
3. Apply the Variable List to the Key Schema field:
   
   

The finished automation:

Notes:

• If the billing is PROVISIONED, the ProvisionedThroughput must explicitly include both ReadCapacityUnits and WriteCapacityUnits:
  

  "ProvisionedThroughput": {
    "ReadCapacityUnits": 5,
    "WriteCapacityUnits": 5}

• There is a known issue when using PAY_PER_REQUEST as the billing mode. This should be fixed in the next releases.

Environment

• Qlik Cloud Analytics
• Qlik Automate

Pressing a button that executes an Automation fails with:

Bad request

An additional error may be shown:

You are not authorized to run this automation

These errors are typically seen after changing the Automation's owner. 

Resolution

Bad request

When the owner of an Automation is changed, the system automatically disables that Automation. In this context, this error indicates that the automation is disabled or that its run mode is incorrectly configured.

To resolve this:

• Ensure the Automation has its status set to Enabled (A)
  
  If it is set to Disabled, click the Actions (...) menu (B) to enable it.
  
  
  
  
• Verify the Automation's Run mode is set to Triggered. If the Automation is set to a different mode (such as Manual or Scheduled), the button will not be able to initiate it.
  
  
  1. Open your Automation and select the Start node
  2. In Inputs, verify Run Mode to be set to Triggered
     
     
     
     
     

You are not authorized to run this automation

This error can occur after re-enabling an automation and the execution token having changed.

Follow these steps to re-establish the connection:

1. Navigate to the sheet where the button containing the automation execution action is located.
2. Edit the sheet and locate the Actions and navigation pane.
3. Find the specific action configured to trigger the automation.
4. In the Automation section, remove the currently selected automation name.
   
   
   
   
5. Click Edit sheet to save this change. This signals the system that the automation link has been cleared.
6. Click Edit sheet and navigate back to the same Automation action.
7. Use the dropdown arrow in the Automation field to select the desired automation you want to be triggered.
8. Click Edit sheet to save the re-selected automation.
9. Verify that the button now successfully executes the automation without errors.

As a rule, only use the option to renew the token when strictly needed for security reasons.

Cause

This is a known design limitation.

As specified in both the dialog and in the documentation (source), “Renewing the execution token for the following automation(s) will immediately break any reference to the automation(s) through a trigger URL or Qlik Sense button object. This action cannot be undone.”

The purpose of introducing the option to renew the token was to harden the security of automations when it comes to webhooks. With this feature, administrators now have the option to break all current webhook connections to an automation if they feel that security concerns require that.

Since buttons also use the same execution tokens, they will also be affected.

The option to renew the execution token should therefore only be used when strictly required by security concerns, e.g., if a token was exposed publicly.

Environment

• Qlik Cloud Analytics
• Qlik Automate