The new Data Quality API allows you to programmatically compute and retrieve data quality
results for datasets in Qlik Cloud.
The API allows evaluating the quality of a dataset based on a sample of its rows. It returns counts of valid, invalid,
and empty cells within the sample. This helps you assess the trustworthiness of your data, especially as it may be
consumed downstream by analytics, AI models, or other consumers.
The new endpoints are:
POST /v1/data-qualities/computations: Trigger a data quality computation.
GET /v1/data-qualities/computations/{computationId}: Retrieve the status of a data quality computation.
GET /v1/data-qualities/global-results: Retrieve global data quality results for a dataset.
The new Tasks API allows you to manage tasks and task chains in Qlik Cloud.
This API adds support for more complex workflows, including scheduled execution, event-based triggers, and task
orchestration with up to 10 tasks per resource.
Warning
Existing reload tasks can be migrated to the new tasks service.
However, once a Qlik Sense app has one or more tasks, reload tasks are turned off for that resource.
The new endpoints are:
GET /v1/tasks: List tasks the requesting user has access to
POST /v1/tasks: Create a new task
GET /v1/tasks/{id}: Get task details
PUT /v1/tasks/{id}: Update a task
DELETE /v1/tasks/{id}: Delete a task
POST /v1/tasks/{id}/actions/start: Start a task
GET /v1/tasks/{id}/runs: List task runs
GET /v1/tasks/resources/{id}/runs: List runs for a resource
GET /v1/tasks/{id}/runs/last: Get the most recent task run
GET /v1/tasks/{id}/runs/{runId}/log: Get a specific task run log
These operations require reload permission on the target resource.
Tenant admins can call GET /v1/tasks and DELETE /v1/tasks/{id}, even without this permission.
As part of improvements to the Data Connections
and Data Credentials APIs
to support the update of credentials on existing connections without
knowing the specific encoding format, a breaking change will be made to the supported
payload structure for the following endpoints:
In both cases, the payload of the call will change from an object format:
{
"patchData": [
{
"op": "add",
"path": "/qName",
"value": "New value"
}
]
}
To an array format:
[
{
"op": "add",
"path": "/qName",
"value": "New value"
}
]
These changes make the APIs more consistent with others in the platform, while
adding support for making updates to additional properties.
Breaking change
These breaking changes will take effect on or after May 23, 2025.
After these changes are deployed, PATCH requests using the old payload format will return a 400 status.
You can update your integration to use the new format if a 400 status is returned.
To enhance the usability and clarity of the REST API documentation on qlik.dev,
a breaking change will be made to the downloadable OpenAPI specifications available in
the REST API Reference.
Currently, the OpenAPI specifications are missing key elements that limit their compatibility with third-party tools.
The upcoming update will address this.
The following enhancements will be introduced:
The servers.url field, which is currently empty, will be updated to use a templated URL.
All endpoint paths will be updated to include the full API prefix. For example: /v1/apps will become /api/v1/apps.
OpenAPI spec servers example
servers:
- url: "https://{tenant}.{region}.qlikcloud.com"
variables:
tenant:
default: your-tenant
description: Name of the tenant that will be called
region:
default: us
description: The region the tenant is hosted in
OpenAPI spec paths example
paths:
/api/v1/apps:
get:
summary: List all apps
description: Retrieve a list of apps.
operationId: listApps
parameters:
- name: limit
in: query
description: The maximum number of results to return.
required: false
schema:
type: integer
default: 100
These changes will make it easier to import the specifications into third party tooling without any modifications.
Breaking change
These breaking changes will take effect on or after May 19, 2025.
The Machine Learning API has been updated with new endpoints that allow you to deploy multiple models,
referenced as aliases, within a single deployment.
The new system of aliases allows you to seamlessly swap models without modifying deployment configurations or disrupting
downstream integrations.
The new endpoints are:
POST /v1/ml/deployments/{deploymentId}/models/actions/add - Add deployed models to the specified deployment
POST /v1/ml/deployments/{deploymentId}/models/actions/remove - Remove models from the specified deployment
POST /v1/ml/deployments/{deploymentId}/aliases - Create an alias
GET /v1/ml/deployments/{deploymentId}/aliases - Retrieve a list of aliases
GET /v1/ml/deployments/{deploymentId}/aliases/{aliasId} - Retrieve an alias
PATCH /v1/ml/deployments/{deploymentId}/aliases/{aliasId} - Update an alias
DELETE /v1/ml/deployments/{deploymentId}/aliases/{aliasId} - Delete an alias
POST /v1/ml/deployments/{deploymentId}/aliases/{aliasName}/realtime-predictions/actions/run - Generate real-time
predictions using an alias
Developers embedding Qlik Sense can now hide specific items in visualization menus to create a more focused user
experience, without relying on CSS workarounds.
When you configure which items should appear in the menu, only those turned on will be shown.
New items added in future Qlik releases will be hidden by default and must be manually turned on.
As of version 2.0.0, the hover menu is enabled by default for newly created KPI chart (sn-kpi) objects.
Existing objects are not affected and will continue to use their current hover menu setting.
Qlik is announcing a change in behavior for the Users API,
which will take effect no sooner than March 31, 2025.
The Users API currently allows you to create a new user with an email that is
already associated with a disabled user in the tenant, and to update a user’s
email to the same address already associated to another invited or disabled user
in the tenant.
The Users API will be updated to enforce email uniqueness across all
user statuses (including: active, invited, provisioned, disabled).
The Data Integration Projects API has been updated with new endpoints that allow users to
validate and prepare their projects and tasks programmatically.
Using these new API endpoints, users can programmatically:
Validate and prepare tasks at the project level, using the internal project orchestration
logic:
Validate all tasks in a project: POST /api/v1/di-projects/{ProjectID}/actions/validate
Prepare all tasks in a project: POST /api/v1/di-projects/{ProjectID}/actions/prepare
Validate and prepare tasks at the task level:
Validate a task: POST /api/v1/di-projects/{ProjectID}/di-tasks/{dataTaskID}/actions/validate
Prepare a task: POST /api/v1/di-projects/{ProjectID}/di-tasks/{dataTaskID}/actions/prepare
Monitor the status of validate and prepare operations to ensure
they are completed successfully before running tasks:
Get status: GET /api/v1/di-projects/actions/{ActionID}
These new endpoints can be leveraged alongside the existing Export and Import endpoints
to fully automate deployment use cases programmatically.
The Spaces API has been updated to include new endpoints to manage
space shares.
This supports two tasks:
Sharing a resource (for example, a Qlik Sense application) to specific users or groups
in a tenant without giving them access to other content in that space.
Managing analytic links for Qlik Sense apps in a tenant with the anonymous
capability enabled.
The new endpoints are:
POST /api/v1/spaces/{spaceId}/shares - Share a resource in a space with specific users
or groups, or create a link share in an anonymous tenant.
GET /api/v1/spaces/{spaceId}/shares - Get a list of shares for a space.
GET /api/v1/spaces/{spaceId}/shares/{shareId} - Get a share by ID.
PATCH /api/v1/spaces/{spaceId}/shares/{shareId} - Update a share by ID.
DELETE /api/v1/spaces/{spaceId}/shares/{shareId} - Delete a share by ID.
New blocks in the Qlik Platform Operations connector:
Create Group: A replacement for the renamed Create Multiple IdP Groups block.
Supports creation of either IdP or custom groups.
Update Group: Updates existing IdP or custom groups.
Add Or Remove User From Custom Group: Adds or removes the specified user from the
provided custom group.
Create Multiple Pinned Links: Permits bulk creation of pinned links.
Create Pinned Link: Creates a pinned link.
List Pinned Links: Retrieves a list of all pinned links.
Get Pinned Link: Retrieves a pinned link.
Update Pinned Link: Updates a pinned link.
Delete All Pinned Links: Bulk deletes all pinned links.
Delete Pinned Link: Deletes a pinned link.
List Analytics App Media Files: Retrieves a list of media files from a Analytics app.
Get Analytics App Media File: Retrieves the specified media file from a Analytics app.
Get Analytics App Thumbnail Media File: Retrieves the thumbnail image for a Analytics app.
Upload Analytics App Media File: Uploads a media file to a Analytics app.
Delete Analytics App Media File: Deletes the specified media file from a Analytics app.
Updated blocks in the Qlik Platform Operations connector:
List Members From Space: Added new inputs to filter directly on the ID of a
user or group, assignee type, and querystring.
Create Group has been renamed to Create Multiple IdP Groups following the
launch of custom groups.
Use the replacement Create Group block if you wish to leverage custom groups.
Update Group has been renamed to Update Group Roles following the launch of
custom groups. Use the replacement Update Group block if you wish to update
properties of custom groups.
Add Role To Group By Name: has been updated to support custom groups. Note
that the default behavior is to add roles to IdP groups. If you wish to add
roles to custom groups, you must specify the group type as custom in the block
configuration.
Remove Role From Group By Name: has been updated to support custom groups.
Note that the default behavior is to add roles to IdP groups. If you wish to add
roles to custom groups, you must specify the group type as custom in the block
configuration.
New blocks in the Qlik Cloud Services connector:
Copy Data File: Duplicates the specified data file.
Get Analytics App Media File: Retrieves the specified media file from a Analytics app.
Get Analytics App Thumbnail Media File: Retrieves the thumbnail image for a
Analytics app.
Upload Analytics App Media File: Uploads a media file to a Analytics app.
Delete Analytics App Media File: Deletes the specified media file from a Analytics
app.
Updated blocks in the Qlik Cloud Services connector:
List Members From Space: Added new inputs to filter directly on the ID of a
user or group, assignee type, and querystring.
List Analytics App Media Files: Renamed from List Media Files In App to align
with naming of new media file handling blocks.
Pinned links are now available in the Qlik Cloud navigation menu. Pinned links
allow you to create and manage your own links which appear under the More
section in the navigation menu, providing a way of surfacing important links to
your users via the global navigation controls.
This feature can only be set via the Pinned Links API. By
default, your tenant contains no links, and the More section will not be shown.
When the first link is added, it will be visible to all users in the tenant.
For example, to create a link to qlik.dev and qlik.com:
Qlik Cloud leverages an event-driven architecture to communicate between the
services in the platform. As part of an ongoing project to standardize event formats,
the event com.qlik.v1.reporting-service.audit is being replaced
by com.qlik.v1.report.finished. Users who consume this event via the
Audits API should migrate to the new event immediately.
As of this changelog, both events will be emitted until May 5, 2025.
On or after this date, the com.qlik.v1.reporting-service.audit event will no longer
be captured. Events already stored by the Audits API will remain available.
The new event is identical to the existing event, with the exception of the
eventType field. The eventType field will be updated from
com.qlik.v1.reporting-service.audit to com.qlik.v1.report.finished.
Note: The com.qlik.v1.reporting-service.audit event is experimental and unpublished.
In general, Qlik does not post deprecation notices for experimental and/or unpublished
events. An exception has been made in this case due to the external
usage of this event. Qlik reserves the right to deprecate without notice experimental
and/or unpublished events.
For more information, review the Audits API specification.
Custom Groups are a powerful new capability designed to give enterprise customers greater flexibility and control over
user and group management.
With Custom Groups, organizations that do not rely on Identity Provider (IdP) groups for access control can now create
and maintain user-to-group relationships directly in Qlik Cloud. This enables seamless group-based provisioning for both
administrative access and product feature controls.
Use Cases Solved
Public Sector Flexibility: Manage group memberships within Qlik Cloud to streamline resource access without
relying on IdP-provided groups, simplifying integration with third-party applications.
Enterprise Autonomy: Gain full control over user and group assignments without being tied to IT-managed Active
Directory groups, empowering teams to adapt quickly to evolving needs.
Embedded Analytics: With qlik-embed and OAuth2 Machine-to-Machine impersonation, use Custom Groups to handle
user group membership using only REST APIs and the qlik-api framework, reducing complexity.
Custom Groups offer enhanced usability and autonomy, making access management easier and more aligned with your unique
organizational structure.
API example: Create a custom group
Here’s an example of how to create a custom group and assign a role to it using the Groups API:
Note: This is a non-breaking addition to the Groups API. Group creation requests sent without a providerType
will continue to be created as an IdP group.
Updated on January 16, 2025: Paths to the invoke and stream endpoints were corrected.
Qlik Answers leverages two services - Knowledgebases and Assistants - to first build the
data leveraged by an assistant and then configure the assistant. The Knowledgebases API
and Assistants API are now published and generally available
for programmatic use cases.
These APIs support both the configuration of Qlik Answers, as well as asking questions
to an Assistant by using the /api/v1/assistants/{assistantId}/threads/{threadId}/actions/invoke
or /api/v1/assistants/{assistantId}/threads/{threadId}/actions/stream
endpoints, allowing you to create your own embedded version of Qlik Answers.
This release complements the previously available qlik-embed support for Qlik Answers,
which allows you to embed the native user interface into your web applications
and portals.
The Machine Learning API is now available. This public API allows you to train, deploy, and make predictions with
machine learning models using Qlik AutoML. You can use this API to integrate the power of Qlik AutoML and predictive
analytics into your own software applications.
With the Machine Learning API, you can:
Start the automated machine learning process by creating machine learning experiment and training models.
Deploy the trained models to make predictions on the outcome of your business problems.
Explore the variables that impact the predicted outcome, and gain a thorough understanding of your data.
For more information about the new Machine Learning API:
This release adds native file handling support, which allows for files up to
100 MB in size and works with a larger selection of connectors.
New blocks:
Import App: A version of the Import App From Base 64 Encoded File block which uses
native file handling.
Export App: A version of the Export App To Base 64 Encoded File block which uses
native file handling.
Import File From Temporary Contents: A version of the Import Base 64 Encoded File To Temporary Contents
block which uses native file handling.
Export File From Temporary Contents: A version of the Export Base 64 Encoded File From Temporary Contents
block which uses native file handling.
Import And Replace App In Shared Space By Name: A version of the Import And Replace Base 64 Encoded App In Shared Space
block which uses native file handling.
Renamed blocks:
Import And Replace Base 64 App In Shared Space By Name: This block was formerly
Import And Replace App In Shared Space, and has been renamed for consistency
with other file handling blocks.
New export/import APIs for Qlik Talend Cloud Pipelines offer a programmatic way
to export and import projects across tenants and spaces for deployment purposes.
They allow programmers to export projects as a .zip file. They also include
creating projects and reading or updating the project variables (referred to as bindings)
before importing project contents.
New endpoints allow you to create, update, and delete custom roles, as well as
configure the default scopes assigned to all users in a tenant via userDefault.
The selection bar can now be styled using custom themes.
Style the selection bar and listboxes with custom definitions for the dataColors properties.
These properties can be configured in the top-level theme definition, and at the chart level for the listBox object.
Republished qlik-cli documentation to remove deprecated commands and update with
improved API specifications.
Updated command help to match the updated API specifications.
Deprecated the collection change-visibility command as the supporting API is
no longer published.
Renamed the flag webhook ls --eventType to --eventTypes to align with the operation
of the API. This flag now takes multiple event types, separated by commas, to support
more precise queries. The old flag still works and is ported to the new one for
backwards compatibility.
Notes on deprecation of collection change-visibility command
The supported method for changing the visibility of a collection is to use
collection patch, for example:
Support for the anonymous OAuth type has been added to qlik-embed, which allows
you to leverage the Anonymous Access capability for embedding Qlik Sense components
with qlik-embed.
The Brands API, initially launched for use by Qlik OEM customers, is now
available to all Qlik customers. You can find the original release in
this changelog. This API helps
improve alignment with your corporate branding and reduces friction
for your end users as they switch between experiences.
The Reloads API is used to start and monitor the refresh of Qlik
Cloud Analytics apps.
To better support programmatic external task management of
reloads, the rate limit for POST /api/v1/reloads
has been increased from 10 requests per minute to 50 requests per minute.
Requests to this POST endpoint are metered over a 5-minute window. This means you
can make up to 250 requests within that window before you are rate limited.
A new tutorial is available with example code for exporting data from a chart
embedded with qlik-embed.
In this tutorial, you will learn how to use qlik-embed and qlik-api to
set up an export button that connects to the reports and temporary contents
APIs to request and retrieve data exports in Microsoft Excel (xlsx) format.
Qlik is enhancing security and data protection for the Extensions API
and Themes API. These APIs allow customization of experiences in Qlik Sense
by adding custom visualization objects, colors, and styling.
Currently, any user in the tenant can download the full archive of an extension or
theme from the following endpoints:
To improve security, only users with the TenantAdmin or AnalyticsAdmin
roles will be allowed to download the full archive. This brings these endpoints
in line with the permissions for import endpoints.
This change will take effect no sooner than 60 days from the date on this changelog, on,
or after October 21, 2024.
The reloads API allows for triggering data refreshes in Qlik
Sense applications in Qlik Cloud.
The query log default value is being changed from true to false. This
will reduce response size for the majority of queries where the log attribute
in the response is not required.
The query parameter log can have a true or false value that controls
whether the log attribute is sent in the response. Today, the default value of
this log parameter is true, when not specified - hence the log is returned
by default.
To continue receiving this attribute after the notice period, you should
specify log=true in your request.
This change will take effect no sooner than 30 days from the date on this changelog, on,
or after September 19, 2024.
Endpoints affected:
GET /v1/reloads
The current response, when no log query parameter is included in the request, returns the log field.
{
"data": [
{
"id": "65ad4a0df4bd1ffb55555a51",
"appId": "349216c2-5555-5555-5555-5555379f68bb",
"tenantId": "xqFQ0k66vSR555555-55555QkiYrCpct",
"userId": "nEgFMHPnm6ye55555555PSKuCUDzEtFO",
"type": "chronos",
"status": "SUCCEEDED",
"log": "ReloadID: 65ad4a0df4bd1ffb55555a51\nStarted loading data\n(A detailed script progress log can be downloaded when the reload is finished)\nreload-result-join-22-23 \u003c\u003c reload-result-join-22-23 446,756 Lines fetched\n\nApp saved\nFinished successfully\n",
Add query parameter log=true to return the log attribute in the response,
such as in /reloads?appId=349216c2-5555-5555-5555-5555379f68bb&log=true:
{
"data": [
{
"id": "65ad4a0df4bd1ffb55555a51",
"appId": "349216c2-5555-5555-5555-5555379f68bb",
"tenantId": "xqFQ0k66vSR555555-55555QkiYrCpct",
"userId": "nEgFMHPnm6ye55555555PSKuCUDzEtFO",
"type": "chronos",
"status": "SUCCEEDED",
"log": "ReloadID: 65ad4a0df4bd1ffb55555a51\nStarted loading data\n(A detailed script progress log can be downloaded when the reload is finished)\nreload-result-join-22-23 \u003c\u003c reload-result-join-22-23 446,756 Lines fetched\n\nApp saved\nFinished successfully\n",
To prevent breaking changes for current users of POST /v1/data-connections,
some parameter names have changed to incorporate the capabilities from
POST /v1/dcaas/actions/data-connections.
Namely:
The parameter for passing the name of the connection is qName rather than connectionName.
The parameter for passing the ID of the space to create the connection in is space rather than spaceId.
With POST /v1/dcaas/actions/data-connections,
you sent:
Qlik is making changes to the recently updated Automation Connections
API to improve developer experience on this API. The change is being made to the response
from three endpoints, to return all attributes at the root object, rather than
in the data object. No changes are being made to payloads or parameters.
This change will take effect no sooner than sixty days from the date on this changelog entry.
Import And Replace App In Shared Space By Name: Use the Import And Replace App
In Shared Space By Name block to simplify importing apps to a shared space for
deployments where the goal of importing the app is to then publish or republish
that imported copy into a managed space. The block will first identify and delete
any other apps in the shared space with the same name (using an exact case-sensitive
match on the provided name), then import the app and return an object containing
the imported app and the IDs of any deleted apps.
Updated blocks:
Create Space If Not Existing: Added the ability to set and update the space
description.
Deactivate Tenant: Fixed an issue with the example output.
Added oauth-client command for the oauth-clients API
Added automation-connections command for the automation-connections API
Updated app properties exported on qlik app unbuild command
Added CSRF support for Qlik Sense Enterprise client-managed
Tidied up various descriptions
Removed deprecated qlik catwalk commands
Removed deprecated qlik csp-header commands
Added oauth-client command for the oauth-clients API
The oauth-clients API allows you to create and manage OAuth clients, used for
authentication in Qlik Cloud. These are designed to support use cases such as
embedding, automation, orchestration, and more.
Explore the new commands under:
Terminal window
qlikoauth-client
If you’re new to OAuth in Qlik Cloud, explore the OAuth2 overview.
Added automation-connections command for the automation-connections API
Automations are the primary resource for Qlik Application Automation,
which provide no-code methods for integrating with Qlik and third-party services.
Updated app properties exported on qlik app unbuild command
Added missing app properties to the unbuild command, to ensure a more complete
unbuild of the app.
Added CSRF support for Qlik Sense Enterprise client-managed
An upcoming change in Qlik Sense Enterprise client managed will make
it a requirement to include a CSRF-token when establishing websocket connections.
This adds a forwards-compatible fix for that.
Removed deprecated qlik csp-header commands
This deprecated endpoint has now been removed. It was replaced
by qlik csp-origin generate-header.
Deallocate All Licenses From User: This block removes any licenses assigned
to the specified user subject.
Delete User And Deallocate All Licenses: This block removes any licenses assigned
to the specified user ID and deallocates any licenses assigned to the
user subject associated with that user ID.
Updated blocks:
Run Automation: Now supports providing the input payload for the automation
within the block.
Qlik Application Automation provides you with the ability to create workflows in a no-code
interface. Most Application Automation connectors
require a connection to a data source, containing information on where the data
source is, connection credentials, and more.
The updated automation-connections API endpoints provide capabilities for users to manage automation connections
in personal and shared spaces, including, but not limited to, retrieving, creating, updating and deleting an
automation connection, as well as changing its owner and moving it to a different space.
This is useful for collaborations and administration, and also when programmatically deploying,
backing up, and restoring automations.
In the initial release, you could retrieve a list of connections:
Note that the connectorId value isn’t currently available via published API. For now,
retrieve this value by viewing the ID of a previously created connection of the type you require.
Review the Automation Connections
API specification for more information about this API.
Qlik has added the com.qlik.v1.analytics.analytics-app-client.sheet-view.opened
event to the audit service in Qlik Cloud. This event is triggered whenever a sheet is
displayed in Qlik Sense, allowing for detailed analysis of how many times a sheet
in an app has been viewed and by which user.
A view will be recorded each time the sheet is navigated to by users
accessing via the Qlik Sense client, via iFrame, or via the classic/app
interface with qlik-embed. Events are not generated for any other embedding approaches.
Actions such as toggling between edit and view mode without changing sheet will
not register as additional views of the sheet.
The value of sheetState details the consumption mode active when the user
opened the sheet:
qlik-embed 1.2.0 adds the popular charts on the fly feature to the analytics/chart
ui. This allows you to generate charts from data in a Qlik Sense app, without
the chart existing in the app. You pass a definition, and the chart is created as
requested by your web app.
Here’s an example using qlik-embed web components:
Note: charts on the fly works only with charts available in the analytics/chart
ui in qlik-embed. Please consult the
chart compatibility table
for a list of compatible charts. Use the Viz on the fly ID for the type property.
Update for using context property
Previously an html attribute to the <qlik-embed /> tag could include :json or :number
to indicate which type the string in the attribute should be parsed to. In some environments
the : is not allowed as a html parameter so it is now possible to also use ___
(triple underscore) as a delimiter.
This means you can now set context like this:
<qlik-embed context___json='{ theme: "Breeze" }' ... /> and it will be parsed as json.
Qlik is removing the com.qlik.user-identity.impersonation event from the audits service
in Qlik Cloud. Events of this type will no longer appear in the Events panel in your
tenant’s management console and responses from the audits API will no longer include
this event.
This change is a result of analysis which found the event added little customer
value, with a better solution being to add the actor attribute to service events to
indicate when a user was impersonated. This reduces audit complexity for customers,
as well as the volume of events a customer needs to process to determine the actions
their users are generating in the platform.
Note: The com.qlik.user-identity.impersonation is not deprecated, it is simply
being removed from a service that aggregates and surfaces events for external
consumption.
This change will take effect no sooner than sixty days from the date on this changelog entry.
qlik-embed web components script src attribute changes
A change to the latest release of qlik-embed web components requires references
to the index.min.js file be specified for the library to run.
If you are using qlik-embed web components it is recommended you update the src
property of the script element declaring the full path to the library.
Update the attribute to include /dist/index.min.js in the path. Here is an example of
the new path for the src attribute:
src="https://cdn.jsdelivr.net/npm/@qlik/embed-web-components@1/dist/index.min.js".
Note: If you do not want to use the latest version of qlik-embed web components, it is
possible to set the version in the path.
Here is an example of the src attribute referencing a pinned version of qlik-embed
web components:
src="https://cdn.jsdelivr.net/npm/@qlik/embed-web-components@1.1.1/dist/index.min.js".
Update the oauth-callback page used to handle connectivity between qlik-embed web components
and your Qlik Cloud tenant. Set the src attribute to use oauth-callback.min.js.
The resulting src attribute should look something like this:
src="https://cdn.jsdelivr.net/npm/@qlik/embed-web-components@1/dist/oauth-callback.min.js".
You can learn more about qlik-embed
on the Why qlik-embed page.
The nebula.js extension and mashup library
has been updated to version 5, the next major version.
Users of versions prior to 5.0.0 should be aware of important changes to:
Type updates which align nebula with other Qlik tools
Expanded support for multi-app mashups and web apps
Updated OAuth support for Qlik Cloud
Type updates
To improve compatibility with other Qlik tools, simplify developer onboarding,
and enhance the TypeScript experience,
Nebula now uses the @qlik/api typings for QIX and Engine entities.
Multi-app support fix
This update changes how Nebula handles its cache. Building mashups using
multiple app connections at the same time now works without interference. Previously, a
common cache was used between instances, which could cause issues if apps shared a data
model or if they where duplicates of each other.
Nebula serve updates
The connection setup in nebula serve was updated to improve compatibility with
the Qlik Cloud OAuth setup. If you’ve used this capability before, you need to update
the redirect URL to http://localhost:8000/auth/login/callback.
Like other UIs available through qlik-embed, when you want to use classic/chart
in an embedded analytics context, set the ui property to classic/chart. If you use
qlik-embed web-components it will look something like this:
<qlik-embed
ui="classic/chart"
app-id="<appId>"
object-id="<objectId>"
></qlik-embed>
classic/chart compatibility
classic/chart will render supported visualizations from Qlik Sense applications.
For a full support matrix, refer to
the supported charts page.
Third-party extensions
Third-party extensions may not render properly within embedded contexts compared
to the native Qlik Sense experience if the extension manipulates private code
such as CSS. Manipulating CSS in the native experience is not supported by Qlik,
therefore, it’s not supported in qlik-embed.
Additionally, for best compatibility, it is suggested to enable iframe mode when
working with extensions:
<qlik-embed
ui="classic/chart"
app-id="<appId>"
object-id="<objectId>"
iframe="true"
></qlik-embed>
To learn more about third-party extension compatibility with qlik-embed,
please contact the extension author.
Limitations
classic/chart does not support the following features:
Publish or Republish App to Managed Space: a convenience block which
rolls together the capabilities in Publish App to Managed Space
and Republish App to Managed Space to automatically replace apps if they already
exist with the same name in the managed space.
Allocate Or Update User License: a convenience block for tenants on the user
(professional/analyzer) license model, supporting automated assignment or update
of user licenses in a single block.
RAW API List Request: a block which supports list API calls to RAW endpoints, removing the
requirement for handling looped calls when making RAW calls.
The following blocks have been renamed to improve consistency:
Create Interactive Identity Provider: renamed to Create Interactive OIDC Identity Provider
in preparation for updates to blocks for additional OIDC and SAML configuration
options.
Update Interactive Identity Provider: renamed to Update Interactive OIDC Identity Provider
in preparation for updates to blocks for additional OIDC and SAML configuration
options.
Qlik is introducing support for OAuth impersonation tokens, which can be generated
using a confidential OAuth machine-to-machine client for users in your
Qlik Cloud tenant. Impersonation tokens are ideal for scenarios where:
The identity provider for your web application does not match the one
configured for your Qlik Cloud tenant.
You wish to handle authentication on your backend.
You wish to avoid client-side redirects in the browser.
If you intend to implement a client-side (front-end) authentication strategy or
if your web application does not have a back-end component, you should leverage
OAuth SPA
for your application.
Considerations if moving from JWT
This capability provides a comparable experience to using JWT to authenticate
from a web application to Qlik Cloud, with the benefit of not being blocked by
third-party cookie restrictions.
The key difference is that OAuth impersonation requires that users already
exist in the tenant and uses pre-existing user group mappings, rather than
supporting update of groups on the fly during token requests. This means that:
Users must exist in the tenant prior to requesting an impersonation token. You can
accomplish this with qlik-api as part of the login flow.
You cannot update user-to-group mappings when requesting the impersonation token.
If you wish to leverage groups for your security model, you should first impersonate
a user login on the backend using JWT to associate the required groups with your user.
Learn more about OAuth impersonation
To discover more:
Review the guiding principles
for using OAuth impersonation in Qlik Cloud.
The OAuth clients API is now published and generally available for use in
programmatic use cases, including automation, orchestration, embedded
analytics, and
more.
One common scenario for using this API is OEM embedded use cases. When OEMs
provision new tenants for end customers, this API can be used to create an
OAuth client to support specific use cases, such as OAuth single-page
applications and OAuth impersonation.
The admin.apps scope has additional permissions granting OAuth tokens with
this scope applied non-interactive access to the personal and private resources
end users in tenants can create and curate.
This update helps administrators address several management use cases involving
resources in personal spaces and unpublished content in Qlik Sense applications.
Situations where this new ability is helpful include:
Access orphaned resources and content when users are removed from the tenant.
Change ownership from one user’s personal space to another.
Programmatically publish content in Qlik Sense applications located in shared
or managed spaces.
Extract private content from Qlik Sense applications in managed spaces for
app lifecycle management, such as promoting content to base-level.
Backup and version control resource metadata, such as Qlik Sense applications,
automations, data pipeline definitions, and more.
Migrating resources and content from client-managed Qlik Sense to Qlik Cloud
Analytics, or between Qlik Cloud tenants.
You can use this capability with qlik-cli, qlik-api, or calling tenant REST apis
directly. This capability is not available in Qlik Cloud graphical user
interfaces.
@qlik/api is a collection of javascript modules which each exposes an api
built to make the integration process for javascript solutions as easy as
possible. The library is built for both browser and NodeJS usage and will
seamlessly integrate with qlik-embed libraries.
@qlik/api provides Qlik Cloud REST endpoints and access to the Qlik Analytics
Engine (QIX).
REST
@qlik/api REST interfaces are generated from open-api specifications released
from those Qlik Cloud services that exposes a restful API. The code generation
tool runs using the specs, building typescript for all api calls documented in
the specification. One module per api is generated.
You can learn more about the available modules in
the REST section
of the typescript types repository on
Qlik Open Source.
QIX
Qlik’s Analytics Engine Service (QIX) is the runtime service for Qlik Sense
applications and several analytics services in Qlik Cloud. @qlik/api offers a
fully typed api for connecting to and consuming Qlik Sense Applications
including “Qlik Sense mixins” which previously only was used internally by
in-house Qlik developers.
More info about QIX can be found in
the qix section.
Learn more about @qlik/api in the toolkits section.
This changelog provides 60 days’ deprecation notice of the Typescript version of
the Platform SDK. The library is being replaced with the Qlik API.
The Qlik API offers the same capabilities and access to Qlik Cloud REST APIs
and the Analytics engine, with the addition of officially supported Typescript
types.
Switching from the Platform SDK to the Qlik API is straightforward, requiring only a few modifications
to your code. The major change is in handling authentication when connecting
to your Qlik Cloud tenant.
Authentication with @qlik/api:
//Backend applications
import { auth } from"@qlik/api";
auth.setDefaultHostConfig({
authType:"oauth2",
host:"<hostname>.<region>.qlikcloud.com",
clientId:"<OAuth2_Client_ID>",
clientSecret:"<OAuth2_Client_Secret>",
});
Authentication with Typescript Platform SDK:
constQlik=require('@qlik/sdk').default;
const { AuthType } =require("@qlik/sdk");
constconfig= {
authType:AuthType.OAuth2,
host:"<hostname>.<region>.qlikcloud.com",
clientId:"<OAuth2_Client_ID>",
clientSecret:"<OAuth2_Client_Secret>",
};
(async () => {
constqlik=newQlik(config);
awaitqlik.auth.authorize();
})();
For more information about @qlik/api, refer to
the release changelog
for @qlik/api or visit the toolkit page
at qlik-api.
Qlik is announcing a change in behavior for
the Roles API. This API
currently returns a list of all available roles on the tenant,
and a change is being made to who can access this API.
As of April 9, 2024, only users assigned the Tenant Admin role will be able to
access the roles API. All other users will be denied access with a http 403 error.
How to access role information for non-Tenant Admin users
Today, any user can retrieve role records as shown below. Once
the change is made, any user without the TenantAdmin role
will receive a http 403 forbidden response.
Terminal window
curl"https://<TENANT>/api/v1/roles"\
-H"Authorization: Bearer <ACCESS_TOKEN>"
Terminal window
# Http 200 - Ok
{
"data": [
{
"id":"<ROLE_ID>",
"tenantId":"<TENANT_ID>",
"name":"<ROLE_NAME>",
},
...
],
"links":{
"self":{
"href":"https://<TENANT>/api/v1/roles"
}
}
}
Although users without the Tenant Admin role will not be able to return all roles in the tenant,
they remain able to list the roles that they are assigned either directly, or via group membership.
They can do this via the /api/v1/users/me endpoint.
Note: Some of the block updates below feature breaking changes. Your existing automations will
remain unaffected unless you choose to upgrade by clicking “Upgrade to latest version” on the block.
The following blocks have been added:
Get Analytics Data Connection: retrieves the definition for a specific analytics
data connection.
Create Analytics Data Connection: enables creation of analytics data connections
using the recently
updated data-connections API.
List Analytics Data Sources: lists all data sources available on the tenant
against which data connections can be created.
Get Analytics Data Source Properties: retrieves the properties of a specific
data source for use when determining which connectionProperties to pass into a
Create New Analytics Data Connection block.
List Analytics Data Source Property Mapping: similar to Get Analytics Data Source Properties
but formats the possible connectionProperties for easier programmatic use.
List Analytics Data Source Gateways: lists available Qlik Direct Access Data
Gateways on the tenant for a specific data source.
Add Member To Space If Not Existing, Update If Existing: adds a user or group to
a space if they are not already a member, or updates their roles if they are a
member. Does not update users who are owners of a space.
Count Remaining API Keys: returns the number of API keys that the requesting user
is able to create on the tenant. This is a function of the maximum number of API keys
per user, minus the number of keys the user currently has.
Import Base 64 Encoded File To Temporary Contents: supports importing a base64-encoded
file to the temporary contents service for downstream consumption in another
service, such as report-templates.
Export Base 64 Encoded File From Temporary Contents: supports exporting a base64-encoded
file from the temporary contents service.
Copy Analytics App: copies an analytics app on the same tenant.
Generate Automation Schedule Definition: helps to create a valid automation schedule for
use in the Create automation or Update automation blocks.
The following blocks have been updated:
RAW API Request: breaking change - removed the key value entry input mode for
this block due to incorrect translation of certain data types, leading to API
errors. If you are using this block, make sure to create a copy before
upgrading its version to avoid corrupting the input.
RAW API Request With Headers: breaking change - removed the key value entry input mode for
this block due to incorrect translation of certain data types, leading to API
errors. If you are using this block, make sure to create a copy before
upgrading its version to avoid corrupting the input.
List Analytics Data Connections: additional input parameters have been added
to align with available options on the API.
List API Keys: additional input parameters have been added to align with available
options on the API.
Create API Keys: an example output has been added.
List Collections: a new enum has been added for collection type.
Create Collection If Not Existing: a new enum has been added for collection type.
Create Automation: an input for the automation schedule has been added to the block.
Update Automation: an input for the automation schedule has been added to the block.
Create Group: block output has been updated to return the created group or groups.
Update Roles Of Member From Space: removed unused required input assigneeId.
Update User: added enums for user status.
Publish App To Managed Space: an example output has been added.
Republish App To Managed Space: an example output has been added.
List Users: added information on how to list non-active users.
List Collections: added enum for public collections (publicgoverned).
The following blocks have been renamed to improve consistency:
List Data Connections: renamed to List Analytics Data Connections.
Delete Data Connections: renamed to Delete Analytics Data Connections.
Qlik Sense applications running in Qlik Cloud rely on Analytics Data Connections
to load data from external sources. The first API to support the creation of these
connections was the Data Connectivity as a Service (DCaaS) API released in September
2023 (see the DCaaS changelog),
and this and additional capabilities have now been merged into
the data-connections API.
This release of the data-connections API supports creation of standard analytics
connections, as well as connections via the direct access gateway, to all analytics
data sources.
An example creation request for a MySQL connection via a direct access Data Gateway:
If you are currently using the /api/v1/dcaas paths, you should transition to using
the updated /api/v1/data-connections endpoints.
There are some differences between the parameters the two APIs accept, with data-connections
maintaining legacy naming to remove the need for breaking changes in the API:
The parameter for passing the name of the connection is qName rather
than connectionName.
The parameter for passing the ID of the space to create the connection in is
space rather than spaceId.
Learn more about Analytics Data Connection APIs
To discover more about how to create Analytics Data Connections:
Review the data connections topic
to learn about the overall capability.
To support customers in managing their users, groups, and tenants via API, Qlik has added the fields
parameter to the Users API. This gives customers total control over the data returned when retrieving
an individual user record.
Get user record
You can now specify which user attributes to include in the response. The following example illustrates
how to request the “groups” field to be returned.
Note: This changelog was updated on February 20, 2024 to clarify the customer impact of
this change.
Qlik regularly reviews the resources offered to platform developers to help them
build better solutions with Qlik Products, and has identified low usage of the
open source nebula.js and mobile visualization libraries.
These libraries were originally published to foster collaboration
and engagement with developers as they customized or developed visualizations, but
due to customer feedback and usage data, these will be moved back to closed source.
Moving these projects back to closed source will support
better integration with internal build and test tooling, and free up resources
for investment in these and other visualizations.
No sooner than 30 days from the date of this notice, Qlik will stop updates to
the following repositories, and set them as archived:
Although Qlik will no longer accept community contributions to these repositories,
the consumption of these libraries and components remains unchanged. Customers
should continue to leverage the NPM packages for each component for use in their
web apps. Existing integrations using these NPM packages will not be impacted by
this change.
Any issues found while using the NPM packages should be raised
via Qlik Support.
Get Current Tenant Hostname: returns the hostname for the tenant the automation
is running on.
List Analytics Reloads: returns results from the Reloads API to list analytics
reload information.
Add Role To User By Name: supports addition of individual
roles to users by the name of the role.
Remove Role From User By Name: supports removal of individual
roles from users by the name of the role.
Create collection If Not Existing: checks to see if a collection exists, if so,
returns the collection, if not, creates the collection.
Get Sharing Settings: retrieves the current configuration of the sharing service for
various reporting and sharing features in the tenant.
Update Sharing Settings: changes the configuration of the sharing service to
turn on or off various reporting and sharing features in the tenant.
RAW API Request With Headers: similar to the RAW API Request block, but appends
the response headers to the response body, since some Qlik Cloud APIs
return information in the header.
The following blocks have been updated:
Get API Key Settings: removed the need to pass the tenantId as a block
input, since you can only make requests for the tenant you pass the request to.
Update API Key Settings: removed the need to pass the tenantId as a block
input, since you can only make requests for the tenant you pass the request to.
Update Collection: added support for changing collection type from private to
publicgoverned to support managing public collections.
The following blocks have been renamed to improve consistency:
Enable Data Alerts: renamed to Update Data Alert Settings.
Get Auto Create Group Setting: renamed to Get Auto Create Group Settings.
Update Auto Create Group Setting: renamed to Update Auto Create Group Settings.
Trigger Enable Notes Settings: renamed to Update Notes Settings.
This changelog provides 30 days’ notice of the deprecation and removal of two attributes
in the POST /v1/sharing-tasks endpoint. This endpoint is used to create new sharing
tasks. Other methods are not affected.
Previously, the attributes allowed you to provide a different name for an asset than the system name.
With the upcoming changes, the service will no longer apply user-provided values,
instead, it will use the system name of the asset.
The attributes are:
root>appName - the name of the source Qlik Sense application
root>excelData>name - the name of the report template used to generate output
No changes are needed to your code, as the API will continue to accept payloads with
these attributes, but it will ignore any provided values.
Changes will be made no fewer than 30 days from the date of this notice.
For more information on Qlik’s API policies, please refer to
the API policy page.
Qlik Cloud Data Integration is a powerful data integration fabric that helps
data engineers deliver, transform, and unify enterprise data in real-time via
automated, governed, and reusable data pipelines.
The new di-projects APIs can be leveraged by your usual API tooling, or via the Qlik
Application Automation connector, providing a way to:
List Projects: Retrieves a list of data projects which belong to a given data space
List Data Tasks: Retrieves a list of data tasks that belong to a given data project
Get Project: retrieves a data project’s information using its ID
Get Data Task: Retrieves a single data task, using the project and task IDs
Start Data Task: Starts a data task run, using the project and task IDs
Stop Data Task: Stops a data task run, using the project and task IDs
Get Data Task Runtime State: Retrieves the runtime state of a data task,
using the project and task Ids returning the list of data integration
With this first iteration, users are able to create workflows that run Qlik Cloud
Data Integration tasks, such as:
Starting a data task, waiting for it to finish, and proceeding to start another
data task.
Implementing conditions in an automation which are not implemented yet in Qlik
Cloud Data Integration,
like running a task only after all the sources have been updated.
Building a workflow that stops CDC tasks before running some backend maintenance
and then starting the CDC task again.
You can leverage Qlik Application Automation to do this without code:
Example API call to retrieve tasks for a project via your own API tooling:
Qlik offers customers the ability to encrypt their tenants with their own
key. The Encryption API
provides you with the ability to deploy, manage, and cycle encryption keys on
one or more Qlik Cloud tenants via supported providers.
Multi-region keys support Disaster Recovery Processes. Tenants configured with a
single-region key will not operate if Qlik Cloud is cut over to a DR region, therefore
Qlik is removing support for single-region keys for new CMK providers. If
you are currently using a single-region key, Qlik recommends that you create a multi-region
key to seamlessly use your tenant in a back-up region in
case of an outage in your primary region.
In no sooner than 30 days from the date of this post, new CMK provider configurations will
require a multi-region key. Existing single-region CMK configurations will not be impacted.
The deprecated Shared filter has been removed from new and updated blocks. This
does not impact blocks which are already in use in running automations.
Previously, the Qlik Platform Operations connector supported cross-tenant API calls
only to the domain *.qlikcloud.com.
This update brings support for calling any Qlik Cloud tenant, including those in
Qlik Cloud Government regions. Due to differences in Qlik Cloud Government, it is
not yet possible to use the tenant create, deactivate, or reactivate blocks on Qlik
Cloud Government tenants.
Additionally, the connector now supports passing a full tenant hostname. This means that you
can now use either of these formats to connect to a tenant:
tenantname.region.qlikcloud.com - the full tenant hostname (recommended)
tenantname.region - the legacy, reduced path
It is now recommended that you use the full tenant hostname on all blocks for any
new automations you create with the Platform Operations connector, by using
the generic Variable block to define the hostname at the automation level.
qlik-embed is Qlik’s new library for embedding data and analytics UI with
confidence and ease. Browsers like Chrome and Safari are making it more complex
to embed content from one software application to another, and you are encouraged to
use qlik-embed to keep pace with evolving privacy and security standards.
With a simple script defining how you want to connect to Qlik, you can embed
content from Qlik applications using web-components as easily as this:
<qlik-embed
id="visualization"
ui="analytics/chart"
app-id="<Qlik Sense Application ID>"
object-id="<Chart object ID>"
></qlik-embed>
You can also take advantage of a framework like React:
Learn more about embedded analytics for the modern
web here, or
explore the reorganised embed section, which
makes it easier to find content for your framework of choice.
If you’d like to jump into a real example, check out
this quickstart.
Qlik is implementing guardrails on uploads to the Extensions and Themes APIs. These
APIs enable the addition of third-party visualizations and third-party formatting
and color schemes for use in Qlik Sense applications.
These changes will take effect no later than 30 days from the date of this notice.
Planned changes:
Maximum archive size: 30 MB - this is larger than any theme currently deployed
to Qlik Cloud, and it is recommended to make themes as small as possible to ensure
that they do not impact the load time in Qlik Sense.
Maximum individual file size: 30 MB - this is linked to the maximum archive
size.
Maximum total size of files in ZIP: 100 MB - this value is based on the uncompressed
size of items in the archive, hence in most cases users will be limited based on
the maximum archive size of 30 MB.
Maximum number of files: 500 - if your theme or extension has more files than this,
consider leveraging a bundler to build similar file types together.
The PATCH method has been added to the Collections API,
giving you the ability to update more collection metadata, with greater flexibility.
The Collections API is the engine behind public and private collections, but also
tags assigned to content in the Items API.
With the PATCH method, you no longer need to send a full PUT payload when
updating collections, simplifying the calls, and reducing access control complexity.
To make a private collection public (assuming you have the appropriate access rights, and at least
one item in the collection), you must change the
type of the collection from private to publicgoverned:
Qlik Application Automation provides you with the ability to create workflows in a no-code
interface. Most Application Automation connectors
require a connection to a data source, containing information on where the data
source is, connection credentials, and more.
The automation-connections API provides a way of returning the list of connections
that the user has access to. This is useful for audits, and also when programmatically
deploying, backing up, and restoring automations.
Note that some connections returned via this API will not be visible in the user
interface. In this example, the Qlik Cloud Services connector automatically generates
and manages its connection on behalf of any user who uses
the connector. This means that the API will return the connection, but users will
not be able to manage it. Review the documentation
for each connector
for connection details.
Review the Automation Connections
API specification for more information about this API.
The query parameter orphans has been added to the Licenses API to help identify
licenses assigned to users who do not exist in the tenant upon which the call is
made.
Assignment of licenses is keyed on the user subject, which is a unique string
provided by the Identity Provider. These assignments are handled separately to users
in the tenant, since a single entitlement can support more than one Qlik Cloud tenant,
or Qlik Sense Enterprise Client-managed site. This means that calls to the users API
on a tenant will return only users on that tenant, while a call to licenses/assignments
returns all global assignments to that entitlement.
In use cases where you have only 1 tenant, and want to track down and remove
assignments not linked to users, you can leverage the below API call, or automation
snippet to return a list of these assignments.
The format for OAuth 2.0 access tokens issued by Qlik Cloud has changed to
remove private data about the access token for security purposes. With this
change access tokens no longer include information about the tenant or user.
Do not inspect access tokens. They are to be treated as opaque values. Qlik
Cloud access token format is not documented and is subject to change.
Client applications can use the access token to obtain data from Qlik Cloud
using published APIs. For example, the client can request user information from
the api/v1/users/me endpoint with the access token.
For change purposes, here is the new format of the access token compared to the
old format.
The query parameter spaceType has been added to the Items API to help better
support programmatic CICD workflows where you need to deploy and manage content
across different space types.
Supported space types for the filter:
shared
managed
data
personal
This new query parameter is useful for listing items within just one specific space type
or within a couple of selected space types.
Note: The query parameter shared is now deprecated in favor of the new
query parameter spaceType,which provides support for all space types as opposed
to just shared spaces. shared will be removed no sooner than 60 days from the
date of this notice.
Qlik offers customers the ability to encrypt their tenants with their own
key. The
new encryption API
provides you with the ability to deploy, manage, and cycle encryption keys on
one or more Qlik Cloud tenants via supported providers.
Create & migrate to a new key provider
Here’s an example of a cURL command that creates a new key provider:
The result is a JSON object that shows the details of the newly created KMS key provider.
{
"name": "<KEY_PROVIDER_NAME>",
"tenantId": "<TENANT_ID>",
"arn": "<KMS_KEY_ARN>",
"arnFingerPrint": "<ARN_FINGERPRINT>",
"keyprovider": "AWS-KMS",
"createdAt": "2023-07-14T18:17:23Z",
"promotedToCurrentAt": "0001-01-01T00:00:00Z",
"demotedFromCurrentAt": "0001-01-01T00:00:00Z"
}
You can then migrate from the currently active key
provider to the new key provider specified by <ARN_FINGERPRINT>. Upon
successful migration, the migrated key provider becomes active.
This changelog provides 60 days notice of deprecation and removal of
the /v1/automations/settings endpoints.
These endpoints turn on and off Qlik Application Automation on a tenant, and this
capability was superseded by the addition in July 2023 of a new role, Automation Creator.
This new role provides much greater flexibility in who can use automations, including
at tenant, group, and user level.
For more information on Qlik’s API policies, please refer to
the API policy page.
Migrating to use the automation creator role
To provide all users in the tenant with access to create and run automations,
you must add the AutomationCreator role to the Everyone group.
Assuming the Everyone group already had the PrivateAnalyticsContentCreator role
assigned, you would send a request to replace the assignedRoles with the new list
of PrivateAnalyticsContentCreator and AutomationCreator:
The query parameter “type” has been added to the Spaces API.
Supported filter values: user or group.
This feature is useful for limiting the number of assignments returned from the endpoint
in cases where only one of the assignment types is of interest.
Update: This changelog was updated to add information on the other services
impacted by this change, and how to move to the new event on 2023-11-23. The event change
was deployed on 2023-11-14.
Qlik Cloud leverages an event driven architecture to communicate between the
services in the platform. To support customer use cases, Qlik surfaces some of these
events. These events may be made accessible in several ways, via:
The event emitted when an analytics reload completes, com.qlik.app.reload.ended,
will be replaced by com.qlik.v1.app.reload.finished no sooner than 30 days from
this notice. The events presented in the webhooks service, and on the Qlik Cloud
Services connector will also be updated to reflect the new format.
Note: The com.qlik.app.reload.ended event is experimental and unpublished.
In general, Qlik does not post deprecation notices for experimental and/or unpublished
events. An exception has been made in this circumstance because of the external
usage of this event. Qlik reserves the right to deprecate without notice experimental
and/or unpublished events.
The key differences for com.qlik.v1.app.reload.finished are:
Layout and field name changes, such as:
The location of the app ID has changed from data>id to extensions>topLevelResourceId.
The location of the space ID has changed from data>spaceId to extensions>spaceId.
The statements section will not return data, since more complex reloads can make
the payload of the event too large. You can still access this information using
the app
reload metadata API endpoint, if required.
Updated on December 6, 2024: The API referenced in this changelog is now deprecated.
For more information, review this 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.
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.
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)
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:
Tenants are the highest level of logical separation in Qlik Cloud available to
Qlik customers. When using a multiple tenant entitlement, you can now
programmatically 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:
Typescript v0.24.0: New API Intakes and Maintenance
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.
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:
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.
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.
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 behavior
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.
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:
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.
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.
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 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.
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.
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
awaitapp.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
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
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.
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.
feat added support for listing app script versions
// saves a script with version called `v1`
constscript='Load RecNo() as N autogenerate(100);';
awaitapp.createScript({
script,
versionMessage:'v1',
});
// retrieves all versions of the app script
const { scripts } =awaitapp.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:
For ES6-Modules and node-fetch you can use
global.fetch = (args) => import('node-fetch').then(({default: fetch}) => fetch(args));
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.
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
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:
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.
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.
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.
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.
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:
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.
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.
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
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
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 Cloud.
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).
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.
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.
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:
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:
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.
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.
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
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:
Terminal window
qlikwebhookedit<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.
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.
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.
Terminal window
chocouninstallqlik-cli
chocoinstallqlik-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 Cloud 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.
Terminal window
qlikquestionask--app-id<appId>--text="new cases by department over time"
#returns a QueryResponse object containing conversational response
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
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 experimental 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.
Updated definitions for URL parameters and updated examples in the
documentation.
Extension 1.1.1
Numerous documentation updates throughout the API.
Distribution family API updates
Conditions 7.8.1 released public stable
The conditions API handles the evaluation of conditions set on data in Qlik
Sense applications. You can use this API to establish conditions and execute
condition evaluation.
Web Notifications 1.2.0 released public stable
Web notifications are tied to alerting in Qlik Cloud and enable developers
to identify the count of read versus unread notifications, and read information
stored in generated web notifications.
Governance family API updates
Data Connections 1.0.0 released public stable
The Data Connections API enables creating, reading, updating, and deleting data
connections for spaces and Qlik Sense applications.
Reload 2.2.0 updated
The latest version of the Reload API supports partial reload with a new
true/false property you can set.
The evaluations API now includes a property in the result schema and the
evaluation detail properties indicating the file size on disk of the evaluated
Qlik Sense application.
The export app
endpoint in the apps API now provides a location header
containing the URL of the exported application in the temporary content service
when the endpoint returns an http 201 response.
Sense Client Object Definitions Released
Developers have requested the schemas and property definitions
for the different objects created in Qlik Sense applications be made public. You
can now view this information here.
You’ll find all of the properties in each type of object available in Qlik
Sense, and you can download the specification for use in your own custom
applications.
Webhooks API set to public/stable API status
The webhooks API is now a public and stable API in alignment with the public
release of tenant level webhooks in SaaS platform.
The evaluations API enables you to run performance and scalability tests for
Qlik Sense applications running on Enterprise SaaS editions of the platform.
This API is useful when you have large applications you want to optimize, or
update an application frequently and want to ensure it remains performant.
The license command in qlik-cli enables you to set license assignments for
users in addition to providing metrics related to your tenant’s overall license
footprint.
The evaluation command enables you to trigger Qlik Sense app evaluations
through cli, retrieve the results, and perform additional commands based on the
feedback. A handy command for automating devops of Qlik Sense apps.
New features
Flags that are deprecated in qlik-cli now show a warning message when used.
Terminal window
qlikapi-keyls--sub="test"
"Flag --sub has been deprecated, please don't use it!"
A security enhancement has been made to remove session Ids from log messages
You can now add names to external specifications you sideload into qlik-cli.
Here’s an example: qlik spec add ./my-spec.json --name foo
Breaking change
The response on the app command has changed. Now it returns only information
from the Apps API.
The qlik.dev changelog has an rss feed you can subscribe to by adding the
URL https://qlik.dev/rss.xml to
your preferred feed reader. Now updates from qlik.dev come to you in your inbox
or wherever you consume syndicated content.
Engine REST API (Apps) updated with new attributes
The Engine REST API, aka Apps API, adds attributes for app name and description
for POST and PUT request operations related to publishing and republishing
Qlik Sense applications.
The new checkOriginAppId attribute is a true/false property validating that
the source Qlik Sense application has the same Id as the originally published
app.
"attributes": {
"name": "string",
"description": "string"
},
"checkOriginAppId": true
For more information, see the API reference for republishing a Qlik Sense
application here.
Users API add attributes for user roles
As part of the ongoing work related to updates to users, groups, and roles in
the Users API added additional properties for setting roles
on users and new
roles that may be applied to user records. While this feature is not accessible
in product user interfaces, it does exist in the API. In addition, the Users API
is public/stable.
Collections API adds new response information with app size metrics
Endpoints for the Collections API now include two new properties in the response
object. appFile displays the size of an app on disk and appMemory shows the
size of an app when it is loaded in memory. Both values are displayed in bytes
and appear under the resourceSize property.
"appFile": {
"description": "Size of the app on disk in bytes",
"type": "number"
},
"appMemory": {
"description": "Size of the app in memory in bytes",
The Identity Providers REST API is a Management API for
creating and
updating identity provider configurations in a tenant. For
more information regarding the API, please review the API
reference here.
Licenses API releases two public/stable, three public/experimental endpoints
The Licenses REST API is a Management API for assigning, changing, and
removing license assignments from users in tenants.
This release includes two public/stable endpoints:
The Reloads API is now verified public/stable in Qlik’s API governance system.
The Reloads API was mistakenly set to public/stable in late 2020 after a
breaking change was introduced in the code. Subsequently, the Reloads API was
adjusted to public/experimental before the new year to indicate the correct
status. The outstanding issues with the API have been addressed.
Temporary Contents API released public/stable
The Temporary Contents Service API is now public/stable in compliance with
Qlik’s API governance policy. The TCS is used by other services to
provided
temporary file storage for uploads to the system (for example through Qlik Data
Transfer) and downloads from (for example image and sheet exports from
Qlik Sense
Client).
qlik-cli 1.7.1 enables the qlik app reload command to perform partial reloads
by adding the --partial flag to the end of the command. Update using homebrew
on a Mac, Chocolatey on Windows, or download the linux distro from
https://github.com/qlik-oss/qlik-cli/releases/tag/v1.7.1.
qlik-cli 1.6.0: better, stronger, faster. This release has a number of
performance improvements. Update using homebrew on a Mac, Chocolatey on Windows,
or download the linux distro from
https://github.com/qlik-oss/qlik-cli/releases/tag/v1.6.0.
Are you looking for a way to consume the latest API updates in the
Qlikosphere? Wondering what new tutorials have been added without
having to visit every page on qlik.dev? Need to find out if you are
using the most current version of qlik-cli? Or maybe you want to know
what new APIs are available to you since the last time you visited?
The developer changelog on qlik.dev is the source for all of this and more!
