Changelog

Qlik Sense applications running in Qlik Cloud rely on Analytics Data Connections to load data from external sources. The new Data Connectivity as a Service (DCaaS) API provides you with the ability to provision new Analytics Data Connections to supported sources using any supported authentication type.

This release of the DCaaS API supports creation of direct connections to:

• REST
• Microsoft SQL Server
• Databricks
• Google Big Query
• Amazon S3 (Web Storage and Metadata, via either v1 or v2 connector)
• Google Cloud Storage (Web Storage and Metadata)
• SFTP
• SFDC

Note: Connections via the Direct Access or Data Movement Gateway are not supported in this release. Non-analytics data connections cannot be configured via DCaaS.

Additionally, support for calls to paths /api/v1/dcaas and /api/v1/data-credentials have been added to the Raw blocks in the Qlik Cloud Services connector in Qlik Application Automation (Qlik Platform Operations allows all endpoints by default).

Learn more about Analytics Data Connections

To discover more about how to create Analytics Data Connections:

• Review the data connections topic to learn about the overall capability.
• Visit the create a connection tutorial to begin creating new connections.

The Platform Operations connector is a connector for Qlik Application Automation that makes deploying and managing tenants in Qlik Cloud possible without code.

Block updates:

The following blocks have been added to the connector:

• Deactivate tenant
• Reactivate tenant

These blocks add support for the deactivation, and eventual deletion of tenants from Qlik Cloud. For further information, refer to the delete tenant changelog.

Review how to get started with the Platform Operations connector.

Minimum and maximum values have been added (which were already restricted in the implementation details) for the limit parameter in the /audits endpoint.

• minimum: 1 (minimum value can be set as limit parameter)
• maximum: 100 (maximum value can be set as limit parameter)
• default: 10 (default value of the limit parameter if not set)

Example:

curl --get --location 'https://<TENANT>.<REGION>.qlikcloud.com/api/v1/audits?limit=<LIMIT>' ^
--header 'Authorization: Bearer <API_KEY>'

Review the Audits API specification for further information.

New query parameters have been added to the Reloads API, giving you additional flexibility in monitoring and managing analytics reloads in your tenant.

Additions:

• filter - allows you to filter on status and partial with equals (eq).
• log - allows you to turn off the log that is usually returned with every API call to improve response time.

To filter on a single status (RELOADING),and exclude the logs:

curl --get --location 'https://<TENANT>.<REGION>.qlikcloud.com/api/v1/reloads' ^
--header 'Authorization: Bearer <ACCESS_TOKEN>' ^
--header 'Content-type: application/json' ^
--header 'Accept: application/json' ^
--data-urlencode 'filter=status eq "RELOADING"' ^
--data-urlencode 'log=false'

To filter on multiple statuses (QUEUED and RELOADING), and exclude the logs:

curl --get --location 'https://<TENANT>.<REGION>.qlikcloud.com/api/v1/reloads' ^
--header 'Authorization: Bearer <ACCESS_TOKEN>' ^
--header 'Content-type: application/json' ^
--header 'Accept: application/json' ^
--data-urlencode 'filter=(status eq "RELOADING") OR (status eq "QUEUED")' ^
--data-urlencode 'log=false'

Review the Reloads API specification for further information.

Tenants are the highest level of logical separation in Qlik Cloud available to Qlik customers. When using a multitenant entitlement, you can now programatically delete tenants via API.

If you are a customer with a single tenant entitlement, contact Qlik for assistance with deleting your tenant.

The most common use case for tenant deletion is in an OEM context where you create a tenant per end customer and need to offboard customers and delete their tenant as their contracts with you come to an end. To learn more the lifecycle of OEM in Qlik Cloud, review the Platform Operations tutorial series.

Important! Deleting a tenant is a permanent action. Neither you nor Qlik can restore data from the tenant after it has been purged from Qlik Cloud. Use this capability with caution.

Deactivate & reactivate a tenant

To deactivate a tenant and schedule it for deletion in 15 days, send this request:

curl -L "https://register.eu.qlikcloud.com/api/v1/tenants/TENANT_ID/actions/deactivate" ^
-H "Authorization: Bearer ACCESS_TOKEN" ^
-H "qlik-confirm-hostname: my-tenant.eu.qlikcloud.com" ^
-H "Content-Type: application/json" ^
-H "Accept: application/json"
-d "{\"purgeAfterDays\": 15}"

This response indicates that the tenant is in a deactivated state:

{
    "id": "zWbTyyJ5lzYLnm9taTD49ja4JVdNKBUM",
    "status": "disabled",
    "estimatedPurgeDate": "2023-07-30T14:01:22.000Z"
}

To reactivate a tenant before the estimated purge date, send this request:

curl -L "https://register.eu.qlikcloud.com/api/v1/tenants/TENANT_ID/actions/reactivate" ^
-H "Authorization: Bearer ACCESS_TOKEN" ^
-H "qlik-confirm-hostname: my-tenant.eu.qlikcloud.com" ^
-H "Content-Type: application/json" ^
-H "Accept: application/json"

This response indicates that the tenant is in an activated state:

{
    "id": "zWbTyyJ5lzYLnm9taTD49ja4JVdNKBUM",
    "status": "active"
}

Learn more

To discover more about tenant deletion:

• Review the delete tenants topic to learn about the overall capability.
• Visit the delete a tenant tutorial in the Platform Operation series to view this in context of a programmatic tenant deployment.
• Access the delete tenants API specification to see the full specification.

Typescript v0.24.0: New API Intakes and Maintainance

feat: Intake Brands API

The [brands] API supports the creation and management of brands in the tenant. This allows you to provide a custom logo and favicon to help you enhance the user experience for your users. Below is an example of how you can use the API.

Important: Use of the brands API is permitted for OEM use cases only.

const qlik = new Qlik({...});
// upload a new logo
const logo = fs.readFileSync(path.join(__dirname, 'assets/logo.png'));
const brand = await qlik.brands.create(logo, 'my_awesome_logo');
// activate/deactivate and delete
await qlik.brands.activate(brand.id);
await qlik.brands.deactivate(brand.id);
await qlik.brands.delete(brand.id);

See full API reference here

feat: Intake Tenants API

const { tenants, users } = new Qlik({...});
// checks tenant/me
const { id } = await tenants.getMe();
const { tenantId } = await users.getMe();

// get a tenant & update settings
let tenant = await tenants.get(id);
const orgEnableAnalyticCreationSettings = tenant.enableAnalyticCreation;
await tenant.patch([{ op: 'replace', path: '/enableAnalyticCreation', value: !orgEnableAnalyticCreationSettings }]);

See full API reference here

Bugfixes

• ⚠️ Breaking - fix: method name fixes in various APIs

// example method name changes:
app.recommendInsightAnalyses(...); // was previously app.recommend(...)
automation.retryRun(...); // was previously automation.retry(...)
// & some plural/singular fixes
collections.getFavorites(); // was previously collections.getFavorite()
webhook.getDelivery(...); // was previously webhook.getDeliverie(...)

Other Fixes

• fix: render inline response object
• fix: random nbr in group test by
• fix: bump spectacular.ts to latest

To get started with the Qlik Typescript SDK, clik here

Python v0.16.0: New API Intakes and Fixes

feat: Intake for Brands API

brands = Brands(config=config)
# create upload logo to your tenant
file_dir = os.path.dirname(os.path.abspath(__file__))
logo_path = os.path.join(file_dir, "logo.png")
with open(logo_path, "rb") as logo_file:
    brand = brands.create(logo=logo_file, name="my_awesome_logo")
# get / activate / deactivate
brands.get(brand_id=brand.id)
brands.activate(brand_id=brand.id)
brands.deactivate(brand_id=brand.id)

See full API reference here

feat: Tenants API

tenants = Tenants(config=config)
# fetch information about your tenant
my_tenant = tenants.get_me()

# change settings
tenant_analytic_creation_setting = my_tenant.enableAnalyticCreation
my_tenant.patch(
    data=[
        {
            "op": "replace",
            "path": "/enableAnalyticCreation",
            "value": True,
        }
    ]
)

See full API reference here

feat: Intake for Notes API

notes = Notes(config=config)
# fetch notes settings
notes_settings = notes.get_settings()
# set settings programatically
notes.set_settings(data={"toggledOn": True, "snapshotRelations": True})

fix: [breaking change] variouse plurals/singular method names fixes

# webhooks.get_deliverie(..) changed to:
webhooks.get_delivery(..)
# collections.get_favorite(..) is now:
collections.get_favorites(..)
# and more

See full API reference here

To get started with the Qlik Python SDK, clik here

The Platform Operations connector is a connector for Qlik Application Automation that makes deploying and managing tenants in Qlik Cloud possible without code.

Block updates:

The following blocks have been added to the connector:

• Get tenant name
• Get tenant alias
• Create key provider (part of Customer Managed Keys release)
• Get key provider by fingerprint (part of Customer Managed Keys release)
• Get ongoing migration details (part of Customer Managed Keys release)
• Reset a migration to Qlik provider (part of Customer Managed Keys release)
• List key providers (part of Customer Managed Keys release)
• Trigger migration (part of Customer Managed Keys release)
• Validate key provider (part of Customer Managed Keys release)

The following blocks have been updated in the connector:

• Get tenant - this has been updated to use the new tenants endpoints
• List automations - additional filter options have been added
• Update tenant - made easier to use

Review how to get started with the Platform Operations connector.

Qlik-Cli v2.22.0

feat: Intake of the brands API

This API allows you to manage the branding of a tenant. For example, you can customize logos and favicons with your brand. You can activate this by using the command:

qlik brand create --name=<name> --file-logo=<logo.png> --file-favIcon=<icon.ico>
qlik brand activate <brand-id>

feat: Intake of group-create

The group-create command is a command used for creating groups. It can be used for managing access control for multiple users at the same time. For example, you can create a group called developers with the "Developer" role assigned.

qlik group create --name=developers --assignedRoles='[{"name":"Developer"}]'

You can get a complete list of roles using the command qlik role ls. --assignedRoles accepts either an ID or the name of a role.

feat: Tenant-edit command

The tenant-edit command now allows you to update your tenant-configuration in a command-line-editor of your choice.

• docs: Edit-commands are no longer experimental
• docs: The identity-provider commands are no longer experimental
• fix: Bug when providing required body parameters from a file using the --file flag.

Say hello to the new Example section on qlik.dev. This new section provides you with quick access to commonly used code snippets and scripts you can adapt and integrate into your projects.

Every example in this section will have a card providing a brief description and the language or tool you can use with it.

There are a lot of examples to share with you, and they're being added to the gallery frequently, so make sure to subscribe to the changelog using the RSS link at the top of the page so you can stay up to date.

If you experience an issue with a snippet, please open an issue at the Qlik Cloud examples repository on Qlik's open source Github. Include a link to the example, the problem, and if you have one, your proposed solution.

You can peruse the examples section here.

The Platform Operations connector is a connector for Qlik Application Automation that makes deploying and managing tenants in Qlik Cloud possible without code.

Block updates:

The following blocks have been added to the connector:

• Get group
• Update group
• Add Role To Group By Name
• Remove Role From Group By Name
• Get tenant
• Update tenant
• Create space if not existing

The following blocks have been updated in the connector:

• Create group - this has been updated to leverage the recently released groups REST API

Review how to get started with the Platform Operations connector.

The Platform Operations connector is a connector for Qlik Application Automation that makes deploying and managing tenants in Qlik Cloud possible without code.

Change to ratelimit handling

When making API calls against Qlik's APIs, you are subject to ratelimits as described on our ratelimits page.

Previously, hitting a ratelimit during an automation would cause a failure of the automation, but new handling has been added that has changed the behaviour to respect the retry-after header returned when the ratelimit is hit.

This addition means you can remove any custom ratelimit handling implemented within your automations. It should now result in automations, which were failing previously, running until completion.

This change applies to all blocks on the Platform Operations connector.

Block updates

The following blocks have been updated in the connector:

• Update auto create group settings - this has been updated to ensure that the value of both autoCreateGroups and syncIdpGroups are toggled on each call. This is to ensure parity with the behavior in the management console. If you wish to change these independently in future, use the Raw API call block.

Review how to get started with the Platform Operations connector.

This changelog provides 60 days notice of deprecation and removal of some undocumented attributes from the response of the /v1/licenses/assignments endpoint.

Qlik is making changes to ensure removal of user names and other identifiable information from APIs where the data is available via other, more appropriate APIs.

For more information on Qlik's API policies, please refer to the API policy page.

Deprecation of response attributes

The attributes name and userId will be removed from the response from the /v1/licenses/assignments endpoint. These are optional, undocumented attributes that can be set when assigning a license. It will still be possible to use these attributes in the API filter.

Note: The endpoint will continue to return the user's subject as their primary identifier. Qlik recommends not using personally identifiable information (PII) in the subject attribute in Qlik Cloud. A good practice is to use system generated GUIDs to uniquely identify users.

When set on a license assignment, the response currently looks like:

{
    "subject": "QLIKBOT\\f0e92f326ac77427df155940fec39e6b",
    "type": "professional",
    "userId": "637390ec6541614d3a88d6c1",
    "name": "EU OAuth Client",
    "excess": false,
    "created": "2023-06-29T12:24:34.639Z"
}

After deprecation, the endpoint will return:

{
    "subject": "QLIKBOT\\f0e92f326ac77427df155940fec39e6b",
    "type": "professional",
    "excess": false,
    "created": "2023-06-29T12:24:34.639Z"
}

If you need to look up the userId and name, you can retrieve these using the list users endpoint.

curl --get --location 'https://<tenant>.<region>.qlikcloud.com/api/v1/users' ^
--header 'Authorization: Bearer <token>' ^
--header 'Content-type: application/json' ^
--header 'Accept: application/json' ^
--data-urlencode 'filter=subject eq "QLIKBOT\\f0e92f326ac77427df155940fec39e6b"'

This will return the full user information for the user with that subject, including the most current name and userId (returned as id) attributes.

{
   "data":[
      {
         "id":"637390ec6541614d3a88d6c2",
         "tenantId":"BL4tTJ4S7xrHTcq0zQxQrJ5qB1_Q6cSo",
         "clientId":"f0e92f326ac77427df155940fec39e6b",
         "status":"active",
         "subject":"qlikbot\\f0e92f326ac77427df155940fec39e6a",
         "name":"EU OAuth Client",
         ...

For more information on the license assignment endpoint, please review the v1/licenses/assignments specification.

Qlik-Cli v2.21.0

• feat: Intake for note settings

qlik note settings update --toggledOn=true

• feat: Intake of the transports API

qlik transport email-config ls # list email configuration settings
qlik transport email-config validate # validate the config

• feat: Tenants API - updates

qlik tenant me # get current tenant information
qlik tenant patch <tenantId> 

• fix: make tcs default in data-file create and update by making resumable flag default true

# to set resumable to false
qlik data-file create  --name <fileName> --file <filePath>  --resumable=false

• docs: Explain quotes in body for Windows

• fix: remove deprecated app-evaluator endpoint

• fix: consistency in the data-file command now update use TCS like data-file create

• fix: checks if context already exists in init command

• fix: handle request bodies with a body property

Typescript 0.23.0: Browser friendly library

⚠️ Breaking - in this release all the data structures are now type aliases previously they were data classes

// previously
import { GenericSheetProperties } from '@qlik/sdk';
const sheetProperties = new GenericSheetProperties({...});

// now
import type { GenericSheetProperties } from '@qlik/sdk';
const sheetProperties: GenericSheetProperties = {...};

This change reduces drastically the bundle size of the library making it more optimized for browsers.

• feat: notes settings API

import { Notes } from '@qlik/sdk';
const notes = new Notes({...});
await notes.setSettings({ toggledOn: true });

• feat: transport API email-config

import { Transports } from '@qlik/sdk';
const transports = new Transports({...});
const emailConfig = await transports.getEmailConfig();
const validated = await transports.validate();

• feat: apps API - change-owner on objects

// create a sheet
const sheet = await app.createSheet({ qMetaDef:{ title: 'temp sheet' } });
// change owner of the sheet
await app.changeOwner(sheet.id, { ownerId: anotherUser.id });

• feat: groups API - create groups

You can now create groups using directly the groups API

import Qlik from '@qlik/cli';

const { roles, groups } = new Qlik({...});
// fetch the tenant admin role
const [ tenantAdminRole ] = await roles.getRoles({ filter: 'name eq "TenantAdmin"' });
// create group named avengers with tenant admin role
await groups.create({name: 'avengers', assignedRoles:[{id: tenantAdminRole.id}]})
// fetch the groups
const groups = await groups.getGroups({ filter: 'name eq "avengers"' });

• feat: users API - invite user

const users = new Users({...});
// resend an invitation in swedish
await users.invite({ invitees:[{ email: 'tom.hanks@qlik.com', resend: true, language: 'sv' }] });

• fix: allow using limit from query param for pagination

Python 0.15.0: API updates

• feat: users API - update

qlik = Qlik(config=config)
# resend an invite to a user in your teanant
qlik.users.invite(
    InviteRequest(
        invitees=[{email: "tom_hanks@qlik.com", language: "sv", resend: true}]
    )
)

• feat: groups API - updates

You can now create a groups:

qlik = Qlik(config=config)
tenant_admin_role = qlik.roles.get_roles(filter='name eq "TenantAdmin"')
# create group
data = GroupPostSchema(name="avengers", assignedRoles={ "id": tenant_admin_role[0].id})
new_group = qlik.groups.create(data=data)
# delete group
group = qlik.groups.get(groupId=new_group.id)
group.delete()

• feat: apps API - new features

insight analysis: you now can list ()app.get_insight_analyses()) and get recommandations (recommend) from insight advisor through APIs

change the ownership of generic objects

app.change_owner(objectId = 'objectId', data = { ownerId: 'userId' })

• feat: transport API email-config

config = Config(
    host=self.base_url, auth_type=AuthType.APIKey, api_key=self.api_key
)
q = Qlik(config=config)
email_config = q.transports.get_email_config()
validation = q.transports.validate()

• fix: handle properties with leading numbers
• fix: response type as requests.response

To support customers who wish to manage their users, groups, and tenants via API, Qlik is releasing new and updated APIs to support common tasks such as:

• Setting the tenant name or tenant alias
• Updating tenant auto assignment flags for new users joining the tenant
• Patching assigned roles by name to users and groups. Previously this could only be done for users, and required the use of the role ID
• Seeding groups to the tenant to set up access control prior to user logins. This is important when using Identity Providers other than Azure AD configured with SCIM

There are also important updates to group validation checks that any organization using groups via their Identity Provider should review.

New tenants endpoints

You're now able to read and patch information about your tenant.

curl "https://your-tenant.us.qlikcloud.com/api/v1/tenants/xxxxx-xxxxx-xxxxxxxxxxxxxxxxxxxx" \
 -H "Authorization: Bearer <dev-api-key>"

# Http 200 - Ok
{
  "id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "status": "active",
  "name": "1234567890abcde",
  "hostnames": [
    "1234567890abcde.us.qlikcloud.com",
    "your-tenant-alias.us.qlikcloud.com"
  ],
  "createdByUser": "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
  "created": "2020-10-01T17:58:14.846Z",
  "lastUpdated": "2023-03-23T13:25:12.107Z",
  "autoAssignCreateSharedSpacesRoleToProfessionals": true,
  "autoAssignPrivateAnalyticsContentCreatorRoleToProfessionals": true,
  "autoAssignDataServicesContributorRoleToProfessionals": true,
  "enableAnalyticCreation": false,
  "datacenter": "us-east-1",
  "links": {
    "self": {
      "href": "https://your-tenant-alias.us.qlikcloud.com/api/v1/tenants/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    }
  }
}

curl "https://your-tenant.us.qlikcloud.com/api/v1/tenants/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" \
 -X PATCH \
 -H "Authorization: Bearer <dev-api-key>" \
 -H "Content-type: application/json" \
 -d '[
    {
      "op": "replace",
      "path": "/name",
      "value": "Your Tenant Name"
    }
  ]'

# Http 204 - No Content

For the complete list of supported features, see the Tenants API specifications.

New users API feature

You're now able to create or patch users with assigned roles by name, instead of by role ID.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users" \
 -X POST \
 -H "Authorization: Bearer <api-dev-key>" \
 -H "Content-type: application/json" \
 -d '{
      "tenantId": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "subject": "my/subject",
      "name": "New Username",
      "email": "username@test.example",
      "assignedRoles": [
        { "name": "TenantAdmin" },
        { "name": "Developer" }
      ]
  }'

# Http 201 - Created
{
    "id": "6478e42bce55a79191a3ce8e",
    "tenantId": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "status": "active",
    "subject": "my/subject",
    "name": "New Username",
    "email": "username@test.example",
    "assignedRoles": [
        {
            "id": "6478e405b3558e25bf22bfaf",
            "name": "TenantAdmin",
            "type": "default",
            "level": "admin"
        },
        {
            "id": "6478e405b3558e25bf22bfb6",
            "name": "Developer",
            "type": "default",
            "level": "user"
        }
    ],
    "assignedGroups": [],
    "groups": [],
    "createdAt": "2023-06-01T18:32:11.509Z",
    "lastUpdatedAt": "2023-06-01T18:32:11.509Z",
    "links": {
        "self": {
            "href": "https://your-tenant.us.qlikcloud.com/api/v1/users/6478e42bce55a79191a3ce8e"
        }
    }
}

curl "https://your-tenant.us.qlikcloud.com/api/v1/users/6478e42bce55a79191a3ce8e" \
 -X PATCH \
 -H "Authorization: Bearer <api-dev-key>" \
 -H "Content-type: application/json" \
 -d '[
    {
      "op": "replace",
      "path": "/assignedRoles",
      "value": [
        { "name": "TenantAdmin" },
        { "name": "Developer" }
      ]
    }
  ]'

# Http 204 - No Content

For the complete list of supported features, see the Users API specifications.

New groups endpoints

You're now able to create and patch information about your groups. This includes the ability to assign roles by name or by ID. Creation of groups is supported through the API for pre-seeding access to resources and role assignment prior to user login. Assignment of users to groups continues to be managed by your identity provider.

curl "https://your-tenant.us.qlikcloud.com/api/v1/groups" \
 -X POST \
 -H "Authorization: Bearer <api-dev-key>" \
 -H "Content-type: application/json" \
 -d '{
      "name": "admin group",
      "assignedRoles": [
          { "name": "TenantAdmin" }
      ]
  }'

# Http 201 - Created
{
    "id": "6478e535b778a912a1d543e6",
    "tenantId": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "createdAt": "2023-06-01T18:36:37.871Z",
    "lastUpdatedAt": "2023-06-01T18:36:37.871Z",
    "name": "admin group",
    "status": "active",
    "assignedRoles": [
        {
            "id": "6478e4b071aaa7f293fd71b0",
            "name": "TenantAdmin",
            "type": "default",
            "level": "admin"
        }
    ],
    "links": {
        "self": {
            "href": "https://your-tenant.us.qlikcloud.com/api/v1/groups/6478e535b778a912a1d543e6"
        }
    }
}

curl "https://your-tenant.us.qlikcloud.com/api/v1/groups/6478e535b778a912a1d543e6" \
 -X PATCH \
 -H "Authorization: Bearer <api-dev-key>" \
 -H "Content-type: application/json" \
 -d '[
    {
      "op": "replace",
      "path": "/assignedRoles",
      "value": [
        { "name": "TenantAdmin" },
        { "name": "Developer" }
      ]
    }
  ]'

# Http 204 - No Content

For the complete list of supported features, see the Groups API specifications.

Group validation updates

Maximum name length

Qlik Cloud now limits the length of group names to 256 characters. New groups with names that exceed the character limit will not be created in the tenant. Any pre-existing groups within Qlik Cloud are unaffected by this change.

Users attempting to log in with a group that exceeds the name length limit will be permitted but the new group will be ignored.

Maximum number of groups per tenant

Qlik Cloud now limits each tenant to 10,000 active groups. Upon reaching the limit, no new groups can be created in the tenant until existing groups are removed by an administrator.

Users attempting to log in with a new group that exceeds the maximum number of groups limit will be permitted but the new group will be ignored.

The Platform Operations connector is a connector for Qlik Application Automation that makes deploying and managing tenants in Qlik Cloud possible without code.

Blocks have been added or updated for the following APIs:

• API keys
• Apps
• Automations
• Brands
• Collections
• Content security policies
• Data alerts
• Data files
• Groups
• Licenses
• Identity providers
• Items
• Spaces
• Users

As a reminder, you can use the Raw API Request block to access any API in Qlik Cloud.

Block listing

New blocks:

• Apps
  • Change app object owner
  • Change app owner
• Automations
  • Change automation owner
• Brands
  • Activate brand
  • Create brand
  • Deactivate brand
  • Get brand
  • Get brand file
  • Delete brand
  • List brands
• Collections
  • Create collection
  • Delete collection
  • Get collection
  • List collection items
  • List collections
  • Update collection
• Data alerts
  • Get data alert settings
• Data files
  • Change data file owner
  • Change data file space
  • Copy data file
  • Create data file
  • Delete data file
  • List data file connections
  • Copy data file in space
  • Create data file in space
  • List data files from space
• Identity providers
  • List identity providers
• Items
  • Get item
  • Get item settings
  • List item collections
  • Add item to collection
  • Remove item from collection
  • List items
  • List items for lookup
  • Update item settings
• Users
  • Invite user by email
  • Update user license

Updated blocks:

• Create API key
• List apps
• List content security policies
• List groups
• Update API key settings
• Add member to space with all roles
• Export app to base64 encoded file
• Find user assigned license

Review how to get started with the Platform Operations connector.

No-code Qlik Platform Operations tutorials

The Platform Operations tutorial series demonstrates how to create, configure, and hydrate tenants in Qlik Cloud using APIs and other pro-code tooling.

A new tutorial series shows how to use the Qlik Platform Operations connector for Qlik Application Automation to achieve similar tenant creation, configuration, and hydration activities using the Application Automation no-code experience.

This series introduces basic concepts related to the connector, it's configuration, and some of the things it helps you to achieve in Qlik Cloud for single or multiple tenant deployments.

Review the tutorial series to get started.

Data files API tutorials

Qlik Cloud allows you to upload or create certain file types for storing data within spaces. These files will appear in the DataFiles data connection when using the data load editor or data manager, and will also appear in the Cloud Hub catalog.

This tutorial series is all about data files, how to create them, update them, and delete them in bulk. You'll also learn how they relate to other assets in Qlik Cloud, such as Analytics apps, data connections, data stores, data assets, and data sets.

See the full API reference, or review the tutorial series.

Qlik-Cli (v2.20.4)

feat: Added qlik app insight-analyse command for Insight Advisor analyses. Documentation for the API can be found here

feat: Added command for changing owner of an object. Documentation for the API can be found here

# Change owner for a specific object
qlik app object change-owner --appId <app-id> --objectId <object-id> --ownerId <owner-id>

feat: add publish & unpublish commands for Bookmarks, Dimensions and Measures.

# Publish a bookmark
qlik app bookmark publish <bookmark-id> --app <app-id>
# Unpublish a bookmark
qlik app bookmark unpublish <bookmark-id> --app <app-id>
# Publish a dimension
qlik app dimension publish <dimension-id> --app <app-id>
# Unpublish a dimension
qlik app dimension unpublish <dimension-id> --app <app-id>
# Publish a measure
qlik app measure publish <measure-id> --app <app-id>
# Unpublish a measure
qlik app measure unpublish <measure-id> --app <app-id>

fix: qlik context commands are no longer experimental

fix: qlik-cli is now based on Golang v1.20.4 to resolve security vulnerabilities.

fix: added missing body parameters for qlik qrs commands. This issue was reported on qlik-oss here

v0.22.0: Sense Client Objects & Mixins

• feat: Sense Client Object Defaults support in the SDK

  Added support for Sense Client Objects, users can now easily do operations like:

// fetch the list sheets
const sheetList = await app.getSheets();
// get individual sheet and do operation on it
const sheet =  await app.getSheet(sheetList[0].id);
await sheet.publish()

and more:

// fetch the list fields
const fieldList = await app.getFields();
// fetch fthe list of fields (including system fields)
const fieldList = await app.getFields({ qFieldListDef: { qShowSystem: true } });
// listen to current selections
const currentSelectionsObj = await app.getCurrentSelectionsObject();
await currentSelectionsObj.getLayout();
currentSelectionsObj.on('changed', () => {
  // selections have been toggled
});
// create masterObjects & publish
const createdMasterObject = await app.createMasterobject({ qMetaDef: { title, description } });
// configure app properties
await app.setAppProperties({sheetTitleBgColor: '#ffcf03', sheetTitleColor: '#ffcf03'});
// list bookmarks easily etc...
const bookmarkList = await app.getBookmarks();

• feat: enigma mixins are now enabled by default non raw rpc calls

// ex: to disable the bandwidth-reducing delta protocol you now need to set it to false
await app.open( { delta: false} );

v0.21.1: Maintenance Release

• fix: Exclude nebula example from dep specs

  Excluding nebula example as it uses production non-approved dependencie parcel and nebula/stardust

v0.21.0: New Features and Bugfixes

• fix: Handle property number name

  Added leading underscore to property names starting with number This fixes the problem with groups blocking updating of specs

• fix: Throw engine message error Added a response error interceptor to throw a descriptive error message received from engine

• fix: Replaced Buffer to btoa in browser build

• chore: Refactor env_vars

• chore: Use apiResponseInterceptor and add nebula integration test

  added empty once function next to the on-listener function - this should be a proper once function set properties in the open function: id, handle, type, genericType use apiResponseInterceptor - to set properties on result throw error from apiResponseInterceptor similar to enigma, should this throw an enigma error? wrap constructor for loop in if-isArray because of a non array response - needs investigation add browser integration test for nebula app using cypress

• chore: Added once event listener Once event listeners are called only once on event and removed from listeners

hypercube.once('changed', () => {...});

• chore: Allow event listeners to be async

  Async functions can be added as event listeners

hypercube.on('changed', async () => {...});

• chore: Keep reserved keywords as class members (delete)

Language reserved words are modified only while using as formal parameters and kept as it is in class members which allows parsing request body with reserved words as keys to class object without loosing any fields from request body

Apps API

The apps API provides access to create and manage Qlik Sense and QlikView apps in Qlik Cloud.

To support Qlik customers migrating from Qlik Sense Enterprise Client-Managed to Qlik Cloud, a new endpoint at /v1/apps/{appId}/objects/{objectId}/actions/change-owner has been added. The new endpoint supports changing the owner of app objects in Qlik Sense apps.

This means that administrators can now migrate Qlik Sense apps with no loss of private or community content, ensuring that your users have no interruption in access to all of the objects from Client-Managed, including bookmarks, stories, sheets, snapshots, and more.

A full tutorial demonstrating the migration of an app and reassignment of object ownership is available here.

Note: You must own the object to change it's ownership to another user.

• POST/v1/apps/{appId}/objects/{$objectId}/actions/change-owner : Change owner of object

curl "https://your-tenant.us.qlikcloud.com/api/v1/apps/{appId}/objects/{objectId}/actions/change-owner" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{"ownerId":"string"}'

See full API reference here, or review the full tutorial here.

Brands API

For Qlik customers deploying an OEM use case, Qlik Cloud can be branded to improve alignment with your own portal, software, or brand, reducing friction for your end users as they swap between experiences.

The brands API allows you to provide a custom logo and favicon to help enhance this user experience for your users.

The new API at brands supports the creation and management of brands in the tenant.

Important: Use of the brands API is permitted for OEM use cases only.

• POST/v1/brands : Create a new brand

curl "https://your-tenant.us.qlikcloud.com/api/v1/brands" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: multipart/form-data" \
 -F "logo=@/path/to/file" \
 -F "styles=@/path/to/file" \
 -F "favIcon=@/path/to/file"

See full API reference here, or review the full tutorial here.

Users API - Invite

The Users API provides you with the ability to create, manage, and delete users from Qlik Cloud tenants. Previously, you were only able to add existing Qlik Cloud users to the tenant using a POST request to users with a valid user subject.

The new endpoint at /v1/users/actions/invite supports the addition of new and existing users to your tenant using the email address of the new user.

Users new to Qlik Cloud will receive an email inviting them to register a Qlik Account, and existing users will be prompted to log in with their existing Qlik Account credentials.

Note: Inviting only works for Qlik Account logins. If you are using your own Identity Provider and wish to pre-load users into the tenant, you should leverage Qlik Cloud SCIM capabilities or send a POST request with the desired subject to create the user.

• POST/v1/users/actions/invite : Invites one or more users to Qlik Cloud using their email.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users/actions/invite" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{"invitees":[{"name":"John Smith","email":"john.smith@example.com","resend":true,"language":"en"}]}'

See full API reference here.

Qlik-Cli (v2.19.0)

feat: commands for managing script versions in an app

# List script versions in an app
qlik app script version ls --appId=<appId>

# Create a version of a script
qlik app script version create --versionMessage="Version1" --script="Load RecNo() as N autogenerate(100);" --appId=<appId>

# Get the current version of a script
qlik app script version get current --appId=<appId>

# Get a specific version of a script. The scriptId is returned when listing script versions.
qlik app script version get <scriptId> --appId=<appId>

# Remove a specific version of a script
qlik app script version rm <scriptId> --appId=<appId>

feat: additional support for rows and json output for the qlik app eval command.

# By default the eval command will only return maximum 20 rows of data
qlik app eval <expression> --app=<appId>

# If additional data is wanted the number of rows can now be specified using the --rows parameter
qlik app eval <expression> --rows=5000 --appId=<appId>

# It is also possible to get the hypercube data pages in raw json
qlik app eval <expression> --rows=5000 --appId=<appId> --json

chore: Documentation updates:

• Qlik App Eval

• Qlik App Script

Typescript SDK (v0.19.1)

New APIs (Questions, Audits, App Scripts)

• feat: added support for the Questions API.

  // Ask question regarding the reloaded data
  const question = 'What is the count of Prime?';
  const answer = await qlik.questions.ask({ text: question, app: { id: app.attributes.id } });

• feat: added support for the Audits API.

  // Get the list of event sources
  const sources = await qlik.audits.getSources();

• feat added support for listing app script versions

  // saves a script with version called `v1`
  const script = 'Load RecNo() as N autogenerate(100);';
  await app.createScript({
    script,
    versionMessage: 'v1',
  });
  // retrieves all versions of the app script
  const { scripts } = await app.getScriptVersions();

Features

• feat: Added support for registering an event listener for object changed and closed events.

  If an object handle is invalidated for instance when the data model has changed, then the handle will be part of a change array in the response for the method that caused the change.

  It is now possible to register a listener for an object, where onChanged is a custom defined function.

  hypercube.on('changed', onChanged);

  Handles can also be closed in a session if they are no longer valid. This can happen if for instance you have a handle for a field and the data model is changed/reloaded.

  field.on('closed', onClosed);

Improvements

• fix: improvements for handling fetch depending on environment

  The global.fetch function is assumed to be available, and if not now an error will be returned. If it is not available then it can be added:

  1. For ES6-Modules and node-fetch you can use global.fetch = (args) => import('node-fetch').then(({default: fetch}) => fetch(args));
  2. For CommonJS and cross-fetch you can use global.fetch = require('cross-fetch');

• fix: Handling of websocket close errors. If an error code is set when the websocket is closed, the SDK will now return an error containing the code and reason for being closed.

  // in case of an socket error the err will contain a `closeCode` and a `closeMsg`
  session.on('socket-error', (data) => {
      err = data;
  });

⚠️ Breaking change

Operations on sub-resources ex: get_reloads_log were previously generated as class static methods and required you to have the resource Id as parameter - now fixed.

public async getReloadsLog(reloadId: string): Promise<ArrayBuffer> {...}
// previously requiring appId
public async getReloadsLog(appId: string, reloadId: string): Promise<ArrayBuffer> {...}

This change affects the following resources: Apps, Automations, Collections, Extensions, Spaces, Themes and Weebhooks.

Python SDK (v0.13.0)

New APIs and Maintenance Fixes

• feat: adding support for the Oauth-Tokens API

config = Config(
  host=self.base_url, auth_type=AuthType.APIKey, api_key=self.api_key
)
oauth_tokens = OauthTokens(config=config)
# fetch all tokens for user with <userId>
tokens = oauth_tokens.get_oauth_tokens(userId="<userId>")
# loop through tokens and revoke them
for token in tokens:
    oauth_tokens.delete(token.id)

• feat: added support for the Questions API

  # ask a question about the data
  answer = q.questions.ask(
    QueryCreate(
      app=QlikApp(id=app.attributes.id),
      text="What is the total sum of Prime?",
    )
  )

• feat: added support for Apps Scripts API

  # create a script
  app.create_script(ScriptVersion(script="Load RecNo() as N autogenerate(200);", versionMessage="v1"))
  # list the script versions in the app
  scriptMetaList = app.get_script_versions()
  # get a specific version of a script
  scriptObject = app.get_script_by_version(scriptMetaList.scripts[0].scriptId)
  # get the current script version (latest version)
  currentScriptObject = app.get_script_by_version("current")

• fix: Operations on sub-resources ex: get_reloads_log were previously generated as class static methods and required you to have the resource Id as parameter is now fixed.
• fix: clear all listeners on session and handles closed events
• fix: raise engine connection close error
• fix: pagination users

Here are the latest maintenance releases for the tools and SDKs. Those releases includes a number of bug fixes and security patches.

Python SDK v0.12.0

• fix: add event listener to the RPC session

from qlik_sdk import Auth, AuthType, Config

# custom function that should be called
def opened_listener():
    print("sesssion opened")

# register function for event "opened"
rpc_session.on("opened", opened_listener)

with rpc_session.open() as rpc_client:
...     # opened_listener function is called when "opened" event is received in session

• fix: readonly and allOf fields are now handled

• fix: render param string enums for typings

• fix: set type for the session property

• fix: various improvements in the generated code-structure

Typescript SDK v0.17.0

• feat: adding themes resource

const themes = new Themes({...});

const zipStream = fs.readFileSync(path.join(__dirname, 'assets/red-theme-extension.zip'));

// upload theme
const theme = await themes.create({ name: `red-theme-test-sdk-ts-${Date.now()}` }, zipStream);

• fix: readonly and allOf fields are now handled
• fix: improved typings for nested object types
• fix: bumping all dependencies security patch releases

qlik-cli v2.18.0

• feat: new resource added oauth-token

qlik oauth-token ls          # List OAuth tokens
qlik oauth-token rm <token>  # Revoke an OAuth token by ID

• fix: properly handle deprecated operations and commands

Since the release of the Qlik Cloud platform SDKs earlier this year, the packages have recently been updated. The idea with the Qlik Platform SDKs is to let developers extend solutions without the need to develop them from scratch.

Python SDK (v0.11.0)

• Feat: Allow full path in RAW rest calls. This feature in combination with interceptors unlocks QRS communication, for example:

def inject_csrf_token(req):
    csrf_token = "".join(random.choices(string.ascii_letters + string.digits, k=16))
    req.headers["x-qlik-xrfkey"] = csrf_token
    req.params["xrfkey"] = csrf_token
    return req
win_auth_instance = Auth(config=Config(
    api_key=qseow_api_key, host=qseow_host, auth_type=AuthType.APIKey))
win_auth_instance.rest.interceptors["request"].use(inject_csrf_token)
apps = win_auth_instance.rest(path=f"{qseow_host}qrs/apps/full")

Feat: Added new APIs

• api-keys API

apiKeys = ApiKeys(config=config)
keys = apiKeys.get_api_keys()

• audits API

audits = Audits(config=config)
sources = audits.get_sources()

• Webhooks API

qlik = Webhooks(config=config)
name = "qlik-sdk-py-test"
url = "https://your-tenant.qlikcloud.com/api/v1/automations/{automationId}/actions/execute"
eventTypes = ["com.qlik.v1.app.created", "com.qlik.v1.app.reload.finished"]
headers = {
    "X-Execution-Token": "lXw9BRm1Ba1bb6MOcPDewNvk5WUmdre70bHljfv1KzNMuby9YXwkUExrCgapxoxn"
}
hook = webhooks.create(
    Webhook(name=name, url=url, eventTypes=eventTypes, headers=headers)
)

• Quotas API

quotas = Quotas(config=config)
data = quotas.get_quotas()

• Collections API

 qlik = Qlik(config=config)
# create collection
collection = qlik.collections.create({"name": col_name, "type": "public"})
app = qlik.apps.create({"attributes": {"name": app_name}})
items = qlik.items.get_items(resourceType="app", resourceId=app.attributes.id)
itemId = items[0].id
# add item to collection
collection.create_item({"id": itemId})

• Automations API

qlik = Qlik(config=config)
name = "test-sdk-py-" + str(uuid.uuid1())
# create
automation = automations.create(data=AutomationDetailRequestObject(name=name))
# run
automation.create_run(RunDetailRequestObject(context="detail"))
# list runs
runs = automation.get_runs()
# delete
automation.delete()

• Reload-Tasks API

qlik = Qlik(config=config)
app = qlik.apps.create({"attributes": {"name": "app name"}})
# create
task = qlik.reload_tasks.create(
    PostTaskBody(
        appId=app.attributes.id,
        timeZone="Europe/Zurich",
        recurrence=[
            "RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;BYHOUR=14;BYMINUTE=16;BYSECOND=0",
        ],
    )
)
# list reload tasks
tasks = qlik.reload_tasks.get_reload_tasks(appId=app.attributes.id)
# delete
task.delete()

Docs

• Cleaned up README and dded more dev documents
• New example for auth flows
• Added engima examples in README.md

Fixes

• Inline return objects are generated as dataclasses
• Allow sending dynamic properties for RPC
• Support nested array object

Typescript SDK (v0.16.0)

• Feat: Allow user to use full patch for RAW calls. This feature in combination with interceptors unlocks QRS communication, For example:

const injectXrfKey = ([url, config]) => {
  const _url = new URL(url);
  _url.searchParams.append("xrfkey", "ichBinEinBerlinR");
  const res = [
    _url.toString(),
    {
      ...config,
      headers: {
        "x-qlik-xrfkey": "ichBinEinBerlinR",
        ...config.headers,
      },
    },
  ];
  return res;
};
auth.rest.interceptors.request.use([injectXrfKey]);

const apps = await auth
  .rest(`https://win-server/jwt/qrs/app/full?filter=name eq '${appName}'`)
  .then((resp) => resp.json());

• Feat: Expose session events

const session = await auth.rpc(appId);
session.on("traffic:sent", onTrafficSent);
session.on("traffic:received", (data: any) => {
  /** ... */
});
session.on("opened", onOpened);
session.on("notification:*", onNotification);

• Feat: Added Relaod-Tasks API

const task = await reloadTasks.create({
  appId: app.attributes.id,
  timeZone: "Europe/Zurich",
  recurrence: [
    "RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;BYHOUR=14;BYMINUTE=16;BYSECOND=0",
  ],
});
// list
const tasks = await reloadTasks.getReloadTasks({ appId: app.id });

• Feat: Enum values in method and class props and parameters

• Docs: Added engine examples to README.md

• Fix: set session on Qix returned Object Classes

• Fix: allow initiated objects

• Fix: request and response interceptors promises

• Refactor: EnigmaSession renamed to the more generic RpcSession

For more information see the package links below:

• Typescript
• Python

Please note that the Platform SDK packages are early development releases. So, please expect breaking changes as it updates and stabilize.

OAuth 2.0 Authorization

OAuth is a standard security protocol for authorization and delegation. It allows third party applications to access API resources without disclosing the end-user credentials.

Qlik Cloud supports OAuth 2.0 Authorization Code and Client Credentials flows. The OAuth client can obtain an authorization code or send client credentials header to exchange it with an access token that can be used to access Qlik Cloud APIs.

• Create OAuth in client see tutorial here

Alongside this delivery you will also get OAuth support for tools and libraries.

• OAuth in Qlik-Cli To quickly get started, you can use the qlik-cli command qlik context init for more details, read the get started section in the Qlik-Cli overview page or the using OAuth clients with Qlik-Cli section in Get started with OAuth machine-to-machine tutorial.

• Platform SDKs Back-end application, front-end application, Python or Javascript? no problem. You can find a simple example using enigma.js in the Platform SDKs overview page or in the Using OAuth clients with Qlik Platform SDKs section

Full tutorial OAuth single page applications with nebula.js can be found here

• Capability APIs? Already have a Client Id? just switch the webIntegrationId config with the clientId instead, that's it. See example code in the Build a simple mashup using capability APIs tutorial.

Transport API

The Transport API is the service responsible for managing notification channels and email configurations for the sending of system notifications, as well as updates from analytics services in the hub, such as data alerts and subscriptions.

These notifications provide users with information about events such as failed reloads, users being added to spaces, data alerts being triggered, and regular subscription snapshots being sent to subscribers. Note that any workflows running in application automation (including the report blocks) will use their own SMTP/ email configuration - only system notifications from application automation will be sent via the transport API.

The endpoints in this release provide the ability to configure and review the email server configuration for this service, including the following examples:

• GET/v1/transports/email-config : Returns the email configuration for a given tenant id.

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
 -H "Authorization: Bearer <API-key>""

• PATCH/v1/transports/email-config : Patch the email configuration for a given tenant id.

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
 -X PATCH \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d
 '{
    "op": "replace",
    "path": "/username",
    "value": "New name"
  }'

• DELETE/v1/transports/email-config: Deletes email configuration for a given tenant id.

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
 -X DELETE \
 -H "Authorization: Bearer <API-key>" \

• POST/v1/transports/email-config/actions/send-test-email : Send a test mail with the supplied email info(subject, body, recipient).

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/send-test-email" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
     "body":"string",
     "subject":"string",
     "recipient":"string"
     }'

• POST/v1/transports/email-config/actions/validate : Returns the isValid value for the email configuration for the tenant. Will return false if no email configuration exists.

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/validate" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \

• POST/v1/transports/email-config/actions/verify-connection: Verifies connection to email server for tenant provided via JWT.

curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \

See full API reference here

Beginning November 1, 2022, Qlik is enforcing rate limits to API requests on Qlik Cloud REST APIs. This means any API request originating to a REST API endpoint on Qlik Cloud is subject to rejection if the number of requests to an endpoint exceeds the allowed amount in a specified duration on that endpoint.

NOTE: Read on to learn more about how you may be impacted by API rate limits.

Learn more about API rate limiting at these resources:

• API rate limiting support blog

• API rate limiting details on qlik.dev

• Review the Qlik Cloud API policy

Nebula version 3.0

The 3.0 version of Nebula has been released. It contains bug fixes, dependency updates and a few new features. Below are select updates since version 2.0

v3.0

• Minor bugfixes and dependency updates.

• Updated to internally use material UI v5 and React 18.

  • Breaking change for users of stardust/core source repository In npm package npm package

  • Still compatible with React 17.

• Engima Mocker:

  • New experimental API that allows examples and tests to run without a Qlik Sense Engine You can see source and documentation here

• Improved support for qListObject in Nebula serve dev enviroment.

  • Supernovas/Extensions using qListObject data works better with automated property panel.

• Updated visualisations. New charts have been added and feature updates made to others. For instance:

  • See New Nebula Map
  • and Pivot table
  • See more here .

More Options

• v2.5: DisableCellPadding: reduces padding around visualistions see here

• Listbox: see here

  • v2.6: dense: reduces padding and text size
  • v2.7: frequencyMode: Shows frequency count of values
  • v2.9: checkboxes: Shows values as checkboxes.

Typescript Support

• v2.4: Typescript support
  • Nebula now comes with defined types and the build command now supports visualisations that use typescript.

Read more here

AutoML Dataset Predictions

This API allows the creation and manipulation of machine learning models, and generation of predictions.

With AutoML Dataset Predictions you can:

• GET/api/v1/automl-predictions/{predictionId}/coordinate-shap: Return a file containing the shapley values in coordinate form that are associated with a predictionId.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/coordinate-shap" \
 -H "Authorization: Bearer <API-key>"

• POST/api/v1/automl-predictions/{predictionId}/jobs : Retrieve jobs that are associated with a prediction.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/jobs" \
 -X POST \
 -H "Authorization: Bearer <API-key>"

• GET/api/v1/automl-predictions/{predictionId}/predictions: Return a file containing the predicted values that are associated with a predictionId.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/predictions" \
 -H "Authorization: Bearer <API-key>"

And more, see full API reference here

AutoML Real-time Predictions

With AutoML Real-time Predictions you can:

• POST/api/v1/automl-deployments/{deploymentId}/realtime-predictions: Generate predictions in a synchronous request and response.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-deployments/{deploymentId}/realtime-predictions" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{"schema":{"rows":[],"schema":[{"name":"string"}]}}'

See API reference here.

Lineage

The Lineage API enables users to keep track of the origins and impacted content of the base objects on resource, table, and field levels.

Additionally, the Lineage API supports search, expansion, and overview on the nodes within input and output graphs.

With this API you can:

• GET/v1/lineage-graphs/nodes/{id}: Returns a lineage graph of a source node.

{id}is the QRI of the base node

curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/nodes/{id}" \
 -H "Authorization: Bearer <API-key>"

• GET/v1/lineage-graphs/impact/{id}/source : Returns all levels of the requested root node. {id}is the QRI of the base node

curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/impact/{id}/source" \
 -H "Authorization: Bearer <API-key>"

• POST/v1/lineage-graphs/nodes/{id}/overview: Update lineage flag for this request. {id}is the QRI of the base node

curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/nodes/{id}/overview" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
        "":[]
    }'

• GET/v1/lineage-graphs/impact/{id}/overview: Returns all resource level nodes that are impacted by a change in the source node. {id}is the QRI of the base node

curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/impact/{id}/overview" \
 -H "Authorization: Bearer <API-key>"

And more, see full API reference here.

You can also read more in this tutorial.

Reload tasks

Reload-tasks are the resources of reload tasks. With this API you can:

• GET/v1/reload-tasks: Find and return the tasks that the user can access.

curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks" \
 -H "Authorization: Bearer <API-key>"

• POST/v1/reload-tasks : Create a task for a specified app.

curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
  "appId": "116dbfae-7fb9-4983-8e23-5ccd8c508722",
  "partial": true,
  "timeZone": "string",
  "autoReload": true,
  "recurrence":
  [
    "FREQ=DAILY;BYHOUR=8;BYMINUTE=0;BYSECOND=0",
    "FREQ=WEEKLY;BYHOUR=10;BYMINUTE=0;BYSECOND=0"
  ],
  "endDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
  "startDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
  "autoReloadPartial": true,
  "type": "scheduled_reload"
}'

• PUT/v1/reload-tasks/{taskId}: Update an existing task.

curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks/{taskId}" \
 -X PUT \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
  "appId": "116dbfae-7fb9-4983-8e23-5ccd8c508722",
  "partial": true,
  "timeZone": "string",
  "autoReload": true,
  "recurrence":
  [
    "FREQ=DAILY;BYHOUR=8;BYMINUTE=0;BYSECOND=0",
    "FREQ=WEEKLY;BYHOUR=10;BYMINUTE=0;BYSECOND=0"
  ],
  "endDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
  "startDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
  "autoReloadPartial": true,
  "state": "Disabled"
}'

See full API reference here

The /evaluations API, used to queue evaluations of Sense apps and retrieve various performance metrics, is being deprecated in favor of new API endpoints more consistent with the rest of the Qlik Cloud platform. The affected API endpoints are:

• POST /v1/evaluations
• GET /v1/evaluations
• GET /v1/evaluations/{id}
• GET /v1/evaluations/{id}/download
• GET /v1/evaluations/{baseid}/compare/{comparisonid}
• GET /v1/evaluations/{baseid}/compare/{comparisonid}/download

Migrating to the new endpoints

The capability is not being removed, and the full list of new endpoints can be found on the API reference page for apps.

In summary, the notable changes to the capability except for new paths are:

• The response body for listing evaluations now uses response.data like other REST APIs, instead of response.evaluations
• The response body links field is now aligned with other REST APIs, links.next is renamed to links.next.href, links.prev is renamed to links.prev.href
• The download endpoints are now action endpoints; GET /v1/evaluations/{id}/download is replaced by GET /v1/apps/{id}/actions/download and GET /v1/evaluations/{id}/compare/{comparisonid}/download is replaced by GET /v1/apps/{id}/actions/compare/{comparisonid}/actions/download
• A few fields were dropped as they were either deemed redundant, (technically) unused, or may cause confusion:
  • spaceId
  • userId
  • maxMemoryMiB
  • appOpenTimeSeconds
  • dataModelSizeMiB
  • sheetTitle
  • responseTimeSeconds2
  • cardinal
  • total_count
  • no_of_rows
  • fileSizeMiB

More information regarding how Qlik deprecates APIs can be found in the API policy.

Changes in v2.15.0

• Support for the new automation API with the automation command

  # get an automation
  qlik automation get <automationId>
  # list automation runs
  qlik automation run ls --automationId <automationId>

  See the command documentation here

• Fix: Fail before request on missing path parameter

  qlik item update itemId --file ./my_file
  # now output an explicit error message about required parameters
  Error: required flag(s) "resourceType" not set

• Fix: correct output when using the --json for errors

  qlik extension get don_t_exists --json
  # now outputs json ready to be parsed
  {
      "status": 404,
      "title": "Not found"
  }

Web-integrations

A web integration is a resource representing a list of whitelisted origins that can make requests to a specified tenant. It is the implementation of the CORS mechanism within Qlik Sense SaaS.

With this API you can;

• POST/web-integrations: Creates a web integration.

curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{"name":"My Web Integration","validOrigins":["https://thirdPartyApp.com"]}'

• GET/web-integrations/{id} : Retrieves a single web integration by ID.

curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations/{id}" \
 -H "Authorization: Bearer <API-key>"

• DELETE/web-integrations/{id}: Deletes a single web integration by ID.

curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations/{id}" \
 -X DELETE \
 -H "Authorization: Bearer <API-key>"

And more, see full API reference here

CSRF Token

This API is used to interact with the CSRF token resource in Edge Auth in Qlik elastic environments.

• GET/csrf-token: Returns CSRF token via the qlik-csrf-token header.

curl "https://your-tenant.us.qlikcloud.com/api/v1/csrf-token" \
 -H "Authorization: Bearer <API-key>"

See API reference here

Tenants

Tenants is the resource representing a tenant.

• POST/tenants: Creates a tenant.

curl "https://your-tenant.us.qlikcloud.com/api/v1/tenants" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{"licenseKey":"string"}'

See API reference here

2.14.3

• New: Commands have been updated to reflect the latest API changes.

New API: Users

Updated: Spaces

Updated: Collections

• New: OAuth 2.0 machine-to-machine support. Users are now able to authorize with Qlik Cloud SaaS over client credentials flow.

• New: Added command for tenant creation.

qlik tenant create Note: This only works with specific entitlements such as an active subscription with the multiple tenants entitlement.

• New: Added commands for web-integrations management. Web-integrations enable users to manage whitelisted origins that can make requests to a specified tenant (CORS).

qlik web-integration create --name myAllowList --validOrigins "https://www.google.com"
# returns a web-integration id
{
  "created": "...",
  "createdBy": "***********mSUL6MIzchD_",
  "id": "DSghcTBrzTkJBCN53IjQatRUWIJkvbno",
  "lastUpdated": "...",
  "name": "myQllowList",
  "tenantId": "**********PMZOEbLC9z52Op_G",
  "validOrigins": [ "https://www.google.com" ]
}

• New: Added commands for groups and roles management.

qlik role ls | jq '.[] | select(.name | contains("AnalyticsAdmin"))'
# returns object with role permission for AnalyticsAdmin
{
  "createdAt": "...",
  "description": "...",
  "id": "********36af85d",
  "lastUpdatedAt": "...",
  "level": "admin",
  "name": "AnalyticsAdmin",
  "permissions": [...]
}
qlik group ls
# fetch existing groups
[
  {
    "createdAt": "...",
    "id": "*********df6c8fc0b36c",
    "lastUpdatedAt": "...",
    "name": "Administrators",
    "status": "active",
    "tenantId": "*****OVEWVPMZOEbLC9z52Op_G"
  },
  ...
]

To update to new version, use the command qlik update

previous version updates:

2.13.0

• Fix: Added qlik-cli to User-Agent header
• Fix: Creating IdP fo type JWTAuth now works identity-provider create jwtauth

Click to view full changelog updates

NEW API: Roles

You're now able to list all assignable roles within your tenant.

curl "https://your-tenant.us.qlikcloud.com/api/v1/roles" \
 -H "Authorization: Bearer <API-key>"

# Http 200 - Ok
{
  "data": [
    {
      "id": "605a18af2ab08cdbfad09259",
      "tenantId": "",
      "name": "AnalyticsAdmin",
      "description": "",
      "type": "default",
      "level": "admin",
      "permissions": [
        "automation:delete",
        "automation:disable",
        "automation:enable",
        "automation:list",
        ...
      ],
      "createdAt": "2021-03-23T16:34:55.401Z",
      "lastUpdatedAt": "2022-04-29T12:06:44.246Z",
      "links": {
        "self": {
          "href": "https://your-tenant.us.qlikcloud.com/api/v1/roles/605a18af2ab08cdbfad09259"
        }
      }
    },
    ...
  ]
}

For the complete list of supported features, please see the Roles API specifications.

NEW API: Groups

You're now able to view groups within your tenant.

curl "https://your-tenant.us.qlikcloud.com/api/v1/groups" \
 -H "Authorization: Bearer <API-key>"

# Http 200 - Ok
{
  "data": [
   {
      "id": "603e591b00d28755ad41bd3b",
      "tenantId": "kg1knZuzosd7LR-CfvV7====tenantID",
      "createdAt": "2021-03-02T15:26:19.724Z",
      "lastUpdatedAt": "2021-03-02T15:26:19.724Z",
      "name": "Finance",
      "status": "active",
      "assignedRoles": [
        {
          "id": "60804cf8a77b649c66733f65",
          "name": "Developer",
          "type": "default",
          "level": "user"
        }
      ],
      "links": {
        "self": {
          "href": "https://your-tenant.us.qlikcloud.com/api/v1/groups/603e591b00d28755ad41bd3b"
        }
      }
    },
    ...
  ]
}

For the complete list of supported features, please see the Groups API specifications.

API DEPRECATIONS: Users

With the release of the new roles and groups APIs, a set of users features are being deprecated. As of November 1, 2022 they will no longer be available. Please ensure to follow the migrations to avoid any downtime.

ENDPOINT: GET /users/metadata

Support for this endpoint is being removed. The role names can now be retrieved from the list roles endpoint.

ATTRIBUTE: roles

Support for user.roles is being removed and replaced with user.assignedRoles. Each assigned role reference maps to an instance of a role object.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users/me" \
 -H "Authorization: Bearer <API-key>"

# Http 200 - Ok
{
  ...
  "roles": [
    "TenantAdmin",
    "Developer",
  ],
  "assignedRoles": [
    {
      "id": "60804cf8a77b649c66733f60",
      "name": "TenantAdmin",
      "type": "default",
      "level": "admin"
    },
    {
      "id": "60804cf8a77b649c66733f65",
      "name": "Developer",
      "type": "default",
      "level": "user"
    }
  ]
}

ATTRIBUTE: created, lastUpdated

The attributes created and lastUpdated are being renamed to createdAt and lastUpdatedAt respectively.

PATCH OPERATIONS & PATHS VALUES

Support for the operations set, unset and add are being removed. It's recommended to use the operation replace for modifying the assigned roles.

Additionally, the path /roles is being deprecated in favor of using /assignedRoles

curl "https://your-tenant.us.qlikcloud.com/api/v1/users/123456789012345678901234" \
 -X PATCH \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '[
    {
      "op": "replace",
      "path": "/assignedRoles",
      "value": [
        { "id": "60804cf8a77b649c66733f60" },
        { "id": "60804cf8a77b649c66733f65" }
      ]
  ]'

# Http 204 - No Content

SORTING

Support for the sorting attributes sortBy and sortOrder is being removed and replaced with sort. This query parameter can be prefixed with +/- to indicate the sort order.

Examples:

• sort=+name
• sort=-name
• sort=name

PAGINATION

The pagination query parameters startingAfter and endingBefore are being renamed to next and prev respectively.

QUERY PARAMETER: tenantId

The query parameter tenantId is no longer required and will default to the tenant being accessed.

QUERY PARAMETER: subject, email, status, role

These four user attributes are no longer supported as query paremeters when querying users.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users?subject=1234567890&email=john.smith@corp.example&status=active" \
 -H "Authorization: Bearer <API-key>"

You can now perform the same query using the filter query parameter.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users?filter=subject eq "1234567890" and email eq "john.smith@corp.example" and status eq "active" \
 -H "Authorization: Bearer <API-key>"

For more complex filtering, you can optionally use the new filter endpoint.

curl "https://your-tenant.us.qlikcloud.com/api/v1/users/actions/filter" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
    "filter": "subject eq \"1234567890\""
  }'

For the complete list of supported features, please see the Users API specifications.

Introducing Qlik Application Automation

Happy to announce the release of a new API: Qlik Application Automation.

Qlik Application Automation is a visual no-code approach to connecting applications. The API helps you easily build automated analytics and data workflows.

Examples

Here are a few examples of what you can expect to do with the Qlik Application Automation API:

• Create an automation.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automations" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
     "name":"string",
     "description":"string",
     "workspace":{},
     "state":"available",
     "schedules":[
         {
             "startAt":"2022-01-01 00:00:00",
             "stopAt":"2022-12-01 00:00:00",
             "interval":30,
             "timezone":"Europe/Stockholm"
         }
         ]
    }'

• Enable an automation.
• Retrieve and update automation settings.
• Copy an automation.
• Create a run.

curl "https://your-tenant.us.qlikcloud.com/api/v1/automations/{id}/runs" \
 -X POST \
 -H "Authorization: Bearer <API-key>" \
 -H "Content-type: application/json" \
 -d '{
     "id":"automationID",
     "context":"editor",
     "inputs":{}
     }'

• Retrieves a run.
• Retry a run
• Stop running an automation
• Export a run
• Move automation to another user

For more information you can see API reference

Platform SDK package

As more & more developers integrate & embed Qlik Sense, the need to simplify the development process is paramount. Announcing the new Qlik Platform SDK - a suite of tools, libraries, and documentation that simplifies building high-quality and performant applications on top of the Qlik Sense Platform. The idea is to let developers extend solutions without the need to develop them from scratch.

And the best part? The capabilities of the SDK comes in two programming languages - TypeScript & Python. With TypeScript, you will have improved definitions and enhanced developer experience with modern IDEs and the Python package opens up a whole new scope for the Python developer community to leverage the power of Qlik Cloud APIs.

Looking to get started? Here are the package links:

• TypeScript - https://www.npmjs.com/package/@qlik/sdk#list-of-modules
• Python - https://pypi.org/project/qlik-sdk/#description

Please note that the Platform SDK packages are early development releases. So, please expect breaking changes as it updates and stabilize.

Engine RPC

Two new methods are added to the Engine RPC.

• GetFieldsResourceIds that returns a list of resource ids (QRI) for fields that belongs to the data model. Key fields (that belongs to multiple tables), returns one resource identifier per table. Read more here

• GetFieldsFromExpression that retrives any fields from an expression. Learn more about this here

nebula.js updates

The nebula stardust package now comes with TypeScript definitions. It references the Qlik's Engine definitions published at @types/qlik-engineapi. This will enable developers to take advantage of code autocompletion, verifying correct types, etc. within modern IDE's.

Data Connections API

Two new endpoints are added to the Data Connections API.

• data-connections/actions/delete that deletes multiple connections and is only available to Admins.

• data-connections/actions/update that updates multiple connections and is only available to Admins.

Learn more about this here

Reloads API

The following endpoints are new to the Reloads API.

• GET /reloads: Reloads allows for triggering reloads of apps to refresh its data. Traditionally this has only been possible through the JSON-RPC websocket API, but can now also be done by using this REST API.

• GET /reloads/{reloadId}: Finds and returns a reload record.

• POST /reloads: Reloads an app specified by an app ID.

Read more here

Reporting Service API

The new Reporting Service API provides the ability to generate reports in PNG, PDF, and xlsx formats programmatically. Reports content could be either a single visualization, an entire sheet, a story or a composition of sheets.

Comprises two endpoints:

• POST/reports: Queues a new report request generation
• GET/reports/{id}/status: Gets report request processing status

Learn more here

2.6.0

• New: Added qlik edit command - you can now easily update resources without worrying about the complicated JSON Patch calculations. Based on the EDITOR environment variable, the edit command starts your preferred editor automatically and once your changes are saved, all PUT/PATCH operations are automatically done.

  *If you want to see communication details for your edit call, you can use
  the `--verbose` flag. It displays all HTTP operations that are
  performed including payloads for requests.*
  
  example:
  
  ```bash
  qlik webhook edit <webhookId>
  # this command launches your preferred editor containing the resource in json format
  # changing, for example, the description parameter is the equivalent of doing
  # a patch request with payload:
  # [
  #   {
  #       "op": "replace",
  #       "path": "/description",
  #       "value": "my new description"
  #   }
  # ]
  ```

• New: Added qlik spec get provides more detailed information about added external specs, most notably the path to the added specification.

• New: The auto-generated usage documentation now get automatically published to

  qlik-cli upon new releases.

• Fix: Improved robustness in handling of array subtypes - missing types now return errors. Any included schema is thus required to have proper types defined. Previously, it defaulted to string if the type was missing.

A new tutorial for authorizing sessions to Qlik Cloud using JSON web tokens (JWT) is now available on qlik.dev named

You can learn more by clicking the link preceding or reviewing the online live example qlik-cloud-jwt.

The latest release of qlik.dev features a new documentation section for qlik-cli. Navigate to the

Here's a sample of what you can expect with this new documentation:

Nebula Documentation

Nebula CLI is the main entry point to start making a nebula visualization, enabling a local development server, and building extensions and mashups.

The Nebula CLI now has updated and detailed documentation updates specifically on the following

Nebula serve

Allows to run a nebula visualization with a local web development server.

nebula serve

For more details read here

Nebula build

Used to build a nebula visualization bundle.

nebula build

Read more here

Nebula sense

Used to generate Qlik Sense specific files to use a nebula visualization as an extension.

nebula sense

Learn more about this here

Nebula Charts

While nebula.js provides capabilities & APIs to build mashups and custom visualizations, it's primary purpose is often to display Qlik developed charts. These charts are available through npm under the @nebula.js scope. Learn more about it [here].

Core packages

The new core build allows to significantly reduce the size of bundle, thus bringing down the overhead of downloading large amount of codes to be run. Refer to an example here

Nebula API

nebula.js API has the following new updates:

new useEmbed hook

The useEmbed hook allows access to the Nebula instance inside a chart, for adding charts into charts. Read the API specs.

new useKeyboard hook

The useKeyboard hook enables mashups to do sense-client style keyboard navigation across chart objects. Read the API specs.

new option for Field-listbox

You can now alter property definition for Field-listbox.

Evaluations API

The Evaluations API now includes a new endpoint /evaluations/{id}/download that allows you to download a detailed XML log for your evaluation. Learn more about this here

Items API

When fetching items using the Items API, you now have the ability to filter by three new subtype resources - automation, dataset, and dataasset. Additionally, if you want to speed up response time, you can now omit the actions array from the response by setting the noActionParam to true. This ensures that the actions for each item is not evaluated.

New Natural Language API

The new Natural language API (/questions/actions/ask) enables you to ask questions and context aware partial questions against applications enabled for conversational analytics or a specific app to receive Insight Advisor generated responses and suggestions. Learn more about creating customized conversational analytics interfaces

Users API

In the User definition created, lastUpdated and roles fields have been deprecated.

JSON engine RPC

A new experimental method Doc.SearchValues has been added to the Qlik Associative Engine. For more details read here

The latest version of qlik-cli allows better windows support, support for new APIs and notifications.

Here are the updates.

Chocolatey

qlik-cli is now back to Chocolatey

To install using choco:

choco install qlik-cli

To upgrade qlik-cli using chocolatey: choco upgrade qlik-cli

If you see an error like below:

Error retrieving packages from source The combination of parameters provided to this OData endpoint is no longer supported. Please refer to the this URL for more information about this deprecation.

Then first run: choco source list

Then remove the one matching nuget.org: choco source rm --name=nuget.org

Another way to fix a failing upgrade is to uninstall and reinstall.

 choco uninstall qlik-cli
 choco install qlik-cli

in v2.5.0 / v2.5.1

New - Added support for outbound proxy: you can now set the operating system environment variables called HTTPS_PROXY/HTTP_PROXY with the hostname or IP address of the proxy server.

Note: HTTPS_PROXY takes precedence over HTTP_PROXY for https requests. Qlik CLI supports only Basic Authentication.

Fix - Improve --limit flag descriptions

Fix - Updated the included latest Qlik Sense SaaS API-specifications

in v2.4.0

Updated Commands

Commands have been updated to reflect the latest API changes.

Notifications

Users to be notified when a new version of qlik-cli is available. The notification message contains URL with detailed changelog of the latest release.

Self Update CLI

The self update command enables users to update to the latest version of qlik-cli by simply running qlik update.

OpenAPI specs support

The latest qlik-cli update provides support for OpenAPI specs that define parameters at the path level. In this case, the parameters are inherited by all operations under that path.

Progress Bar

The animated progress bar displayed when uploading an app is now based on estimated upload time.

Support for unix-like Windows terminals

The latest version of qlik-cli provides better support for unix-like Windows terminals (such as MingGW, MSYS2, and Cygwin).

Fix

The latest version of qlik-cli also includes bug fixes and minor improvements.

in v2.3.0

Support for identity-providers endpoint

The identity-providers service is used for managing identity providers. In this version of qlik-cli the support for identity-providers endpoint is provied.

Support for questions endpoint

The questions endpoint lets user ask natural language questions against Qlik Sense apps enabled for conversational analytics. This version of qlik-cli provides support for this endpoint.

qlik question ask --app-id <appId> --text="new cases by department over time"

#returns a QueryResponse object containing conversational response
{
  ...
  "conversationalResponse": {
    ...
    "responses": [
      {
        "imageUrl": "/api/v1/temp-contents/6139c949f0ccf200019a09e2?inline=1",
        "sentence": {
          "text": "new cases by department over time"
        },
        "type": "chart"
      },
      {
        "narrative": {
          "text": "* New Cases is 180.\n* There were 18 of New Cases not associated to a Department. This may indicate a data quality issue."
        },
        "sentence": {
          "text": "new cases by department over time"
        },
        "type": "narrative"
      }
    ],
    "sentenceWithMatches": "**new cases** by **department** over time"
  },

Progress bar for Downloads

The latest version of qlik-cli also shows an animated progress during app download.

Spinner feedback

A new spinner feedback is added when users are waiting for server response using qlik-cli.

The latest version of qlik-cli adds resumable uploads for large Qlik Sense applications and bug fixes to improve overall usability. Here are the updates.

New feature highlights

Import large Qlik Sense apps

You can now upload large apps to SaaS tenants using qlik-cli using the qlik app import command. Use the --resumable switch to instruct the cli to handle the upload as a large file.

When you upload an app using qlik-cli, a nice animated bar appears displaying the progress.

File piping

File piping allows you to combine commands where the output of one may be used as the input of the next command you issue.

Command aliases

Aliases enable you to create shorthand commands for hard to remember long commands. For example, say you run a command frequently to find the guid of an application in your tenant, $(qlik item ls --resourceType app --name. You can use the alias command to create a shortcut it into something like qlik getAppGuid consumer+sales. This returns the complete JSON object for the consumer+sales resource in the items collection.

Limit flag added for listing apps

The --limit switch enables you to return a number of app resource objects per page ranging from 1 to 100.

Identifying experimental flags and switches in commands

Command switches and flags that are experimental features are labeled as such for your information.

Fixes worth mentioning

Temporary Upload Service

Use of the temporary upload service in qlik-cli caused problems with large app uploads and resumability. This problem has been fixed and implemented through the resumable switch in the qlik app import command.

Updated response from reload get command

In prior CLI versions, qlik reload get was not sending a correct response. This issue has been resolved.

Bullet list of all features and fixes in qlik-cli 2.2.0

• feature: add limit flag when listing apps

• feature: Support resumable uploads

• feature: add status for qseow

• feature: Support big apps

• feature: show if a flag or command is experimental

• feature: Add progress-bar

• feature: add support for command aliases

• feature: Add Patch description

• feature: support for files piping

• fix: Solve temporary upload service store issues

• fix: Add timeout to Establish TCP connection

• fix: append exprimental to long description with leading newline

• fix: Honor optional request bodies

• fix: handle empty stdin

• fix: omit cookie header

• fix: updated response for reload get

Update qlik-cli today by using brew if you use a Mac, or download the redistributable from here.