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:
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.
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.
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","partial":false,"creationTime":"2024-01-21T16:45:01Z","startTime":"2024-01-21T16:45:02.766Z","endTime":"2024-01-21T16:45:10.125Z","engineTime":"2024-01-21T16:45:07.915Z","links":{"self":{"href":"https://tenant.region.qlikcloud.com/api/v1/reloads/65ad4a0df4bd1ffb55555a51"}}},]}
In future, if the query param log=true is not specified, or is false, the
log attribute will be omitted from the response:
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","partial":false,"creationTime":"2024-01-21T16:45:01Z","startTime":"2024-01-21T16:45:02.766Z","endTime":"2024-01-21T16:45:10.125Z","engineTime":"2024-01-21T16:45:07.915Z","links":{"self":{"href":"https://tenant.region.qlikcloud.com/api/v1/reloads/65ad4a0df4bd1ffb55555a51"}}},]}
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.
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:
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:
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.
@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.
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.
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.
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.
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:
If the task exists, and you have access to it, you will receive a 200 response
with details of the task:
{"id":"sqlserver_data_landing-5h5M","name":"SQLServer-data_Landing","type":"LANDING","ownerId":"64ff3381259ad349da2046a9","spaceId":"6502c7c2562be31c8343bbd4","description":"This is the landing task for SQL server"}
Now that you have the task, you can start it:
curl"https://your-tenant.us.qlikcloud.com/api/v1/di-projects/{projectId}/di-tasks/{dataTaskId}/runtime/actions/start"\-X POST \-H"Authorization: Bearer <API-key>"
If successful, you will receive a 204 response with no body.
Review the DI projects
API specification for more information about this API.
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.
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-embedid="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:
{"name":"My Public Collection","description":"A logical grouping of content for a business unit or team, which still respects space permissions.","type":"publicgoverned","id":"{collectionId}",
...
}
To unpublish the collection, change the type back to private.
The PATCH operation can also be used on the name and description of the collection.
Review the Collections API specification for
further information.
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:
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 superceeded 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.
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 multitenant entitlement, you can now
programatically delete tenants via API.
If you are a customer with a single tenant entitlement, contact Qlik for
assistance with deleting your tenant.
The most common use case for tenant deletion is in an OEM context where you create
a tenant per end customer and need to offboard customers and delete their tenant
as their contracts with you come to an end. To learn more the lifecycle of OEM in
Qlik Cloud, review the Platform Operations tutorial series.
Important!
Deleting a tenant is a permanent action. Neither you nor Qlik can
restore data from the tenant after it has been purged from Qlik Cloud. Use
this capability with caution.
Deactivate & reactivate a tenant
To deactivate a tenant and schedule it for deletion in 15 days, send this
request:
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.
The apps API provides access to create and manage Qlik
Sense and QlikView apps in Qlik Cloud.
To support Qlik customers migrating from Qlik Sense Enterprise Client-Managed to
Qlik Cloud, a new endpoint at
/v1/apps/{appId}/objects/{objectId}/actions/change-owner
has been added. The new endpoint supports changing the owner of app objects in
Qlik Sense apps.
This means that administrators can now migrate Qlik Sense apps with no loss of
private or community content, ensuring that your users have no interruption in
access to all of the objects from Client-Managed, including bookmarks, stories,
sheets, snapshots, and more.
A full tutorial demonstrating the migration of an app and reassignment of object
ownership is available here.
Note: You must own the object to change it’s ownership to another user.
POST/v1/apps/{appId}/objects/{$objectId}/actions/change-owner : Change owner of object
curl"https://your-tenant.us.qlikcloud.com/api/v1/apps/{appId}/objects/{objectId}/actions/change-owner"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: application/json"\-d'{"ownerId":"string"}'
See full API reference here, or review
the full tutorial here.
For Qlik customers deploying an OEM use case, Qlik Cloud can be branded to improve
alignment with your own portal, software, or brand, reducing friction for your
end users as they swap between experiences.
The brands API allows you to provide a custom logo and
favicon to help enhance this user experience for your users.
The new API at brands supports the creation and management
of brands in the tenant.
Important: Use of the brands API is permitted for OEM use cases only.
POST/v1/brands : Create a new brand
curl"https://your-tenant.us.qlikcloud.com/api/v1/brands"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: multipart/form-data"\-F"logo=@/path/to/file"\-F"styles=@/path/to/file"\-F"favIcon=@/path/to/file"
See full API reference here, or review
the full tutorial here.
The Users API provides you with the ability to create, manage, and delete users
from Qlik Cloud tenants. Previously, you were only able to add existing Qlik
Cloud users to the tenant using
a POST request to users with
a valid user subject.
The new endpoint at /v1/users/actions/invite
supports the addition of new and existing users to your tenant using the
email address of the new user.
Users new to Qlik Cloud will receive an email inviting them to register a Qlik
Account, and existing users will be prompted to log in with their existing Qlik
Account credentials.
Note: Inviting only works for Qlik Account logins. If you are using your
own Identity Provider and wish to pre-load users into the tenant, you should
leverage Qlik Cloud SCIM capabilities
or send a POST request with
the desired subject to create the user.
POST/v1/users/actions/invite : Invites one or more users to Qlik Cloud using their email.
curl"https://your-tenant.us.qlikcloud.com/api/v1/users/actions/invite"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: application/json"\-d'{"invitees":[{"name":"John Smith","email":"john.smith@example.com","resend":true,"language":"en"}]}'
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/send-test-email : Send a test mail with the
supplied email info(subject, body, recipient).
curl"https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/send-test-email"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: application/json"\-d'{
"body":"string",
"subject":"string",
"recipient":"string"
}'
POST/v1/transports/email-config/actions/validate : Returns the isValid value
for the email configuration for the tenant. Will return false if no email configuration exists.
curl"https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/validate"\-X POST \-H"Authorization: Bearer <API-key>"
POST/v1/transports/email-config/actions/verify-connection: Verifies connection to email server
for tenant provided via JWT.
curl"https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/verify-connection"\-X POST \-H"Authorization: Bearer <API-key>"
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.
POST/v1/lineage-graphs/nodes/{id}/overview: Update lineage flag for this request.
{id}is the QRI of the base node
curl"https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/nodes/{id}/overview"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: application/json"\-d'{
"":[]
}'
GET/v1/lineage-graphs/impact/{id}/overview: Returns all resource level nodes
that are impacted by a change in the source node.
{id}is the QRI of the base node
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.
With this API you can;
POST/web-integrations: Creates a web integration.
curl"https://your-tenant.us.qlikcloud.com/api/v1/web-integrations"\-X POST \-H"Authorization: Bearer <API-key>"\-H"Content-type: application/json"\-d'{"name":"My Web Integration","validOrigins":["https://thirdPartyApp.com"]}'
GET/web-integrations/{id} : Retrieves a single web integration by ID.
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:
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
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 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
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.
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.
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","type":"number"}
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 assignements 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).
