Data files API tutorials
Qlik Cloud allows you to upload or create certain file types for storing data within spaces. These files will appear in the DataFiles data connection when using the data load editor or data manager, and will also appear in the Cloud Hub catalog.
This tutorial series is all about data files, how to create them, update them, and delete them in bulk. You'll also learn how they relate to other assets in Qlik Cloud, such as Analytics apps, data connections, data stores, data assets, and data sets.
See the full API reference, or review the tutorial series.
Qlik-Cli (v2.20.4)
feat: Added qlik app insight-analyse
command for Insight Advisor analyses.
Documentation for the API can be
found here
feat: Added command for changing owner of an object. Documentation for the API can be found here
# Change owner for a specific object
qlik app object change-owner --appId <app-id> --objectId <object-id> --ownerId <owner-id>
feat: add publish
& unpublish
commands for Bookmarks, Dimensions and Measures.
# Publish a bookmark
qlik app bookmark publish <bookmark-id> --app <app-id>
# Unpublish a bookmark
qlik app bookmark unpublish <bookmark-id> --app <app-id>
# Publish a dimension
qlik app dimension publish <dimension-id> --app <app-id>
# Unpublish a dimension
qlik app dimension unpublish <dimension-id> --app <app-id>
# Publish a measure
qlik app measure publish <measure-id> --app <app-id>
# Unpublish a measure
qlik app measure unpublish <measure-id> --app <app-id>
fix: qlik context
commands are no longer experimental
fix: qlik-cli
is now based on Golang v1.20.4 to resolve security vulnerabilities.
fix: added missing body parameters for qlik qrs
commands.
This issue was reported on qlik-oss here
v0.22.0: Sense Client Objects & Mixins
feat: Sense Client Object Defaults support in the SDK
Added support for Sense Client Objects, users can now easily do operations like:
// fetch the list sheets
const sheetList = await app.getSheets();
// get individual sheet and do operation on it
const sheet = await app.getSheet(sheetList[0].id);
await sheet.publish()
and more:
// fetch the list fields
const fieldList = await app.getFields();
// fetch fthe list of fields (including system fields)
const fieldList = await app.getFields({ qFieldListDef: { qShowSystem: true } });
// listen to current selections
const currentSelectionsObj = await app.getCurrentSelectionsObject();
await currentSelectionsObj.getLayout();
currentSelectionsObj.on('changed', () => {
// selections have been toggled
});
// create masterObjects & publish
const createdMasterObject = await app.createMasterobject({ qMetaDef: { title, description } });
// configure app properties
await app.setAppProperties({sheetTitleBgColor: '#ffcf03', sheetTitleColor: '#ffcf03'});
// list bookmarks easily etc...
const bookmarkList = await app.getBookmarks();
- feat: enigma mixins are now enabled by default non raw rpc calls
// ex: to disable the bandwidth-reducing delta protocol you now need to set it to false
await app.open( { delta: false} );
v0.21.1: Maintenance Release
fix: Exclude nebula example from dep specs
Excluding nebula example as it uses production non-approved dependencie parcel and nebula/stardust
v0.21.0: New Features and Bugfixes
fix: Handle property number name
Added leading underscore to property names starting with number This fixes the problem with groups blocking updating of specs
fix: Throw engine message error Added a response error interceptor to throw a descriptive error message received from engine
fix: Replaced Buffer to btoa in browser build
chore: Refactor env_vars
chore: Use
apiResponseInterceptor
and add nebula integration testadded 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 fromapiResponseInterceptor
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 cypresschore: Added once event listener Once event listeners are called only once on event and removed from listeners
hypercube.once('changed', () => {...});
chore: Allow event listeners to be async
Async functions can be added as event listeners
hypercube.on('changed', async () => {...});
- chore: Keep reserved keywords as class members (delete)
Language reserved words are modified only while using as formal parameters and kept as it is in class members which allows parsing request body with reserved words as keys to class object without loosing any fields from request body
Apps API
The apps
API provides access to create and manage Qlik
Sense and QlikView apps in Qlik Cloud.
To support Qlik customers migrating from Qlik Sense Enterprise Client-Managed to
Qlik Cloud, a new endpoint at
/v1/apps/{appId}/objects/{objectId}/actions/change-owner
has been added. The new endpoint supports changing the owner of app objects in
Qlik Sense apps.
This means that administrators can now migrate Qlik Sense apps with no loss of private or community content, ensuring that your users have no interruption in access to all of the objects from Client-Managed, including bookmarks, stories, sheets, snapshots, and more.
A full tutorial demonstrating the migration of an app and reassignment of object ownership is available here.
Note: You must own the object to change it's ownership to another user.
POST/v1/apps/{appId}/objects/{$objectId}/actions/change-owner
: Change owner of object
curl "https://your-tenant.us.qlikcloud.com/api/v1/apps/{appId}/objects/{objectId}/actions/change-owner" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{"ownerId":"string"}'
See full API reference here, or review the full tutorial here.
Brands API
For Qlik customers deploying an OEM use case, Qlik Cloud can be branded to improve alignment with your own portal, software, or brand, reducing friction for your end users as they swap between experiences.
The brands
API allows you to provide a custom logo and
favicon to help enhance this user experience for your users.
The new API at brands
supports the creation and management
of brands in the tenant.
Important: Use of the brands API is permitted for OEM use cases only.
POST/v1/brands
: Create a new brand
curl "https://your-tenant.us.qlikcloud.com/api/v1/brands" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: multipart/form-data" \
-F "logo=@/path/to/file" \
-F "styles=@/path/to/file" \
-F "favIcon=@/path/to/file"
See full API reference here, or review the full tutorial here.
Users API - Invite
The Users API provides you with the ability to create, manage, and delete users
from Qlik Cloud tenants. Previously, you were only able to add existing Qlik
Cloud users to the tenant using
a POST request to users
with
a valid user subject
.
The new endpoint at /v1/users/actions/invite
supports the addition of new and existing users to your tenant using the
email address of the new user.
Users new to Qlik Cloud will receive an email inviting them to register a Qlik Account, and existing users will be prompted to log in with their existing Qlik Account credentials.
Note: Inviting only works for Qlik Account logins. If you are using your own Identity Provider and wish to pre-load users into the tenant, you should leverage Qlik Cloud SCIM capabilities or send a POST request with the desired
subject
to create the user.
POST/v1/users/actions/invite
: Invites one or more users to Qlik Cloud using their email.
curl "https://your-tenant.us.qlikcloud.com/api/v1/users/actions/invite" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{"invitees":[{"name":"John Smith","email":"john.smith@example.com","resend":true,"language":"en"}]}'
See full API reference here.
Qlik-Cli (v2.19.0)
feat: commands for managing script versions in an app
# List script versions in an app
qlik app script version ls --appId=<appId>
# Create a version of a script
qlik app script version create --versionMessage="Version1" --script="Load RecNo() as N autogenerate(100);" --appId=<appId>
# Get the current version of a script
qlik app script version get current --appId=<appId>
# Get a specific version of a script. The scriptId is returned when listing script versions.
qlik app script version get <scriptId> --appId=<appId>
# Remove a specific version of a script
qlik app script version rm <scriptId> --appId=<appId>
feat: additional support for rows and json output for the qlik app eval
command.
# By default the eval command will only return maximum 20 rows of data
qlik app eval <expression> --app=<appId>
# If additional data is wanted the number of rows can now be specified using the --rows parameter
qlik app eval <expression> --rows=5000 --appId=<appId>
# It is also possible to get the hypercube data pages in raw json
qlik app eval <expression> --rows=5000 --appId=<appId> --json
chore: Documentation updates:
Typescript SDK (v0.19.1)
New APIs (Questions, Audits, App Scripts)
- feat: added support for the Questions API.
// Ask question regarding the reloaded data
const question = 'What is the count of Prime?';
const answer = await qlik.questions.ask({ text: question, app: { id: app.attributes.id } });
- feat: added support for the Audits API.
// Get the list of event sources
const sources = await qlik.audits.getSources();
- feat added support for listing app script versions
// saves a script with version called `v1`
const script = 'Load RecNo() as N autogenerate(100);';
await app.createScript({
script,
versionMessage: 'v1',
});
// retrieves all versions of the app script
const { scripts } = await app.getScriptVersions();
Features
feat: Added support for registering an event listener for object
changed
andclosed
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 useglobal.fetch = (args) => import('node-fetch').then(({default: fetch}) => fetch(args));
- For CommonJS and
cross-fetch
you can useglobal.fetch = require('cross-fetch');
- For ES6-Modules and
fix: Handling of websocket close errors. If an error code is set when the websocket is closed, the SDK will now return an error containing the code and reason for being closed.
// in case of an socket error the err will contain a `closeCode` and a `closeMsg` session.on('socket-error', (data) => { err = data; });
⚠️ Breaking change
Operations on sub-resources ex: get_reloads_log were previously generated as class static methods and required you to have the resource Id as parameter - now fixed.
public async getReloadsLog(reloadId: string): Promise<ArrayBuffer> {...}
// previously requiring appId
public async getReloadsLog(appId: string, reloadId: string): Promise<ArrayBuffer> {...}
This change affects the following resources: Apps
, Automations
, Collections
,
Extensions
, Spaces
, Themes
and Weebhooks
.
Python SDK (v0.13.0)
New APIs and Maintenance Fixes
- feat: adding support for the Oauth-Tokens API
config = Config(
host=self.base_url, auth_type=AuthType.APIKey, api_key=self.api_key
)
oauth_tokens = OauthTokens(config=config)
# fetch all tokens for user with <userId>
tokens = oauth_tokens.get_oauth_tokens(userId="<userId>")
# loop through tokens and revoke them
for token in tokens:
oauth_tokens.delete(token.id)
- feat: added support for the Questions API
# ask a question about the data
answer = q.questions.ask(
QueryCreate(
app=QlikApp(id=app.attributes.id),
text="What is the total sum of Prime?",
)
)
- feat: added support for Apps Scripts API
# create a script
app.create_script(ScriptVersion(script="Load RecNo() as N autogenerate(200);", versionMessage="v1"))
# list the script versions in the app
scriptMetaList = app.get_script_versions()
# get a specific version of a script
scriptObject = app.get_script_by_version(scriptMetaList.scripts[0].scriptId)
# get the current script version (latest version)
currentScriptObject = app.get_script_by_version("current")
- fix: Operations on sub-resources ex: get_reloads_log were previously generated as class static methods and required you to have the resource Id as parameter is now fixed.
- fix: clear all listeners on session and handles closed events
- fix: raise engine connection close error
- fix: pagination users
Here are the latest maintenance releases for the tools and SDKs. Those releases includes a number of bug fixes and security patches.
Python SDK v0.12.0
- fix: add event listener to the RPC session
from qlik_sdk import Auth, AuthType, Config
# custom function that should be called
def opened_listener():
print("sesssion opened")
# register function for event "opened"
rpc_session.on("opened", opened_listener)
with rpc_session.open() as rpc_client:
... # opened_listener function is called when "opened" event is received in session
fix: readonly and allOf fields are now handled
fix: render param string enums for typings
fix: set type for the session property
fix: various improvements in the generated code-structure
Typescript SDK v0.17.0
- feat: adding themes resource
const themes = new Themes({...});
const zipStream = fs.readFileSync(path.join(__dirname, 'assets/red-theme-extension.zip'));
// upload theme
const theme = await themes.create({ name: `red-theme-test-sdk-ts-${Date.now()}` }, zipStream);
- fix: readonly and allOf fields are now handled
- fix: improved typings for nested object types
- fix: bumping all dependencies security patch releases
qlik-cli v2.18.0
- feat: new resource added oauth-token
qlik oauth-token ls # List OAuth tokens
qlik oauth-token rm <token> # Revoke an OAuth token by ID
- fix: properly handle deprecated operations and commands
Since the release of the Qlik Cloud platform SDKs earlier this year, the packages have recently been updated. The idea with the Qlik Platform SDKs is to let developers extend solutions without the need to develop them from scratch.
Python SDK (v0.11.0)
- Feat: Allow full path in RAW rest calls. This feature in combination with interceptors unlocks QRS communication, for example:
def inject_csrf_token(req):
csrf_token = "".join(random.choices(string.ascii_letters + string.digits, k=16))
req.headers["x-qlik-xrfkey"] = csrf_token
req.params["xrfkey"] = csrf_token
return req
win_auth_instance = Auth(config=Config(
api_key=qseow_api_key, host=qseow_host, auth_type=AuthType.APIKey))
win_auth_instance.rest.interceptors["request"].use(inject_csrf_token)
apps = win_auth_instance.rest(path=f"{qseow_host}qrs/apps/full")
Feat: Added new APIs
- api-keys API
apiKeys = ApiKeys(config=config)
keys = apiKeys.get_api_keys()
- audits API
audits = Audits(config=config)
sources = audits.get_sources()
- Webhooks API
qlik = Webhooks(config=config)
name = "qlik-sdk-py-test"
url = "https://your-tenant.qlikcloud.com/api/v1/automations/{automationId}/actions/execute"
eventTypes = ["com.qlik.v1.app.created", "com.qlik.v1.app.reload.finished"]
headers = {
"X-Execution-Token": "lXw9BRm1Ba1bb6MOcPDewNvk5WUmdre70bHljfv1KzNMuby9YXwkUExrCgapxoxn"
}
hook = webhooks.create(
Webhook(name=name, url=url, eventTypes=eventTypes, headers=headers)
)
- Quotas API
quotas = Quotas(config=config)
data = quotas.get_quotas()
- Collections API
qlik = Qlik(config=config)
# create collection
collection = qlik.collections.create({"name": col_name, "type": "public"})
app = qlik.apps.create({"attributes": {"name": app_name}})
items = qlik.items.get_items(resourceType="app", resourceId=app.attributes.id)
itemId = items[0].id
# add item to collection
collection.create_item({"id": itemId})
- Automations API
qlik = Qlik(config=config)
name = "test-sdk-py-" + str(uuid.uuid1())
# create
automation = automations.create(data=AutomationDetailRequestObject(name=name))
# run
automation.create_run(RunDetailRequestObject(context="detail"))
# list runs
runs = automation.get_runs()
# delete
automation.delete()
- Reload-Tasks API
qlik = Qlik(config=config)
app = qlik.apps.create({"attributes": {"name": "app name"}})
# create
task = qlik.reload_tasks.create(
PostTaskBody(
appId=app.attributes.id,
timeZone="Europe/Zurich",
recurrence=[
"RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;BYHOUR=14;BYMINUTE=16;BYSECOND=0",
],
)
)
# list reload tasks
tasks = qlik.reload_tasks.get_reload_tasks(appId=app.attributes.id)
# delete
task.delete()
Docs
- Cleaned up README and dded more dev documents
- New example for auth flows
- Added engima examples in README.md
Fixes
- Inline return objects are generated as dataclasses
- Allow sending dynamic properties for RPC
- Support nested array object
Typescript SDK (v0.16.0)
- Feat: Allow user to use full patch for RAW calls. This feature in combination with interceptors unlocks QRS communication, For example:
const injectXrfKey = ([url, config]) => {
const _url = new URL(url);
_url.searchParams.append("xrfkey", "ichBinEinBerlinR");
const res = [
_url.toString(),
{
...config,
headers: {
"x-qlik-xrfkey": "ichBinEinBerlinR",
...config.headers,
},
},
];
return res;
};
auth.rest.interceptors.request.use([injectXrfKey]);
const apps = await auth
.rest(`https://win-server/jwt/qrs/app/full?filter=name eq '${appName}'`)
.then((resp) => resp.json());
- Feat: Expose session events
const session = await auth.rpc(appId);
session.on("traffic:sent", onTrafficSent);
session.on("traffic:received", (data: any) => {
/** ... */
});
session.on("opened", onOpened);
session.on("notification:*", onNotification);
- Feat: Added Relaod-Tasks API
const task = await reloadTasks.create({
appId: app.attributes.id,
timeZone: "Europe/Zurich",
recurrence: [
"RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;BYHOUR=14;BYMINUTE=16;BYSECOND=0",
],
});
// list
const tasks = await reloadTasks.getReloadTasks({ appId: app.id });
Feat: Enum values in method and class props and parameters
Docs: Added engine examples to README.md
Fix: set session on Qix returned Object Classes
Fix: allow initiated objects
Fix: request and response interceptors promises
Refactor: EnigmaSession renamed to the more generic RpcSession
For more information see the package links below:
Please note that the Platform SDK packages are early development releases. So, please expect breaking changes as it updates and stabilize.
OAuth 2.0 Authorization
OAuth is a standard security protocol for authorization and delegation. It allows third party applications to access API resources without disclosing the end-user credentials.
Qlik Cloud supports OAuth 2.0 Authorization Code and Client Credentials flows. The OAuth client can obtain an authorization code or send client credentials header to exchange it with an access token that can be used to access Qlik Cloud APIs.
- Create OAuth in client see tutorial here
Alongside this delivery you will also get OAuth support for tools and libraries.
OAuth in Qlik-Cli To quickly get started, you can use the qlik-cli command
qlik context init
for more details, read the get started section in the Qlik-Cli overview page or the using OAuth clients with Qlik-Cli section in Get started with OAuth machine-to-machine tutorial.Platform SDKs Back-end application, front-end application, Python or Javascript? no problem. You can find a simple example using
enigma.js
in the Platform SDKs overview page or in the Using OAuth clients with Qlik Platform SDKs section
Full tutorial OAuth single page applications with nebula.js can be found here
- Capability APIs?
Already have a
Client Id
? just switch thewebIntegrationId
config with theclientId
instead, that's it. See example code in the Build a simple mashup using capability APIs tutorial.
Transport API
The Transport API is the service responsible for managing notification channels and email configurations for the sending of system notifications, as well as updates from analytics services in the hub, such as data alerts and subscriptions.
These notifications provide users with information about events such as failed reloads, users being added to spaces, data alerts being triggered, and regular subscription snapshots being sent to subscribers. Note that any workflows running in application automation (including the report blocks) will use their own SMTP/ email configuration - only system notifications from application automation will be sent via the transport API.
The endpoints in this release provide the ability to configure and review the email server configuration for this service, including the following examples:
GET/v1/transports/email-config
: Returns the email configuration for a given tenant id.
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
-H "Authorization: Bearer <API-key>""
PATCH/v1/transports/email-config
: Patch the email configuration for a given tenant id.
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
-X PATCH \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d
'{
"op": "replace",
"path": "/username",
"value": "New name"
}'
DELETE/v1/transports/email-config
: Deletes email configuration for a given tenant id.
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
-X DELETE \
-H "Authorization: Bearer <API-key>" \
POST/v1/transports/email-config/actions/send-test-email
: Send a test mail with the supplied email info(subject, body, recipient).
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/send-test-email" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"body":"string",
"subject":"string",
"recipient":"string"
}'
POST/v1/transports/email-config/actions/validate
: Returns the isValid value for the email configuration for the tenant. Will return false if no email configuration exists.
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config/actions/validate" \
-X POST \
-H "Authorization: Bearer <API-key>" \
POST/v1/transports/email-config/actions/verify-connection
: Verifies connection to email server for tenant provided via JWT.
curl "https://your-tenant.us.qlikcloud.com/api/v1/transports/email-config" \
-X POST \
-H "Authorization: Bearer <API-key>" \
See full API reference here
Beginning November 1, 2022, Qlik is enforcing rate limits to API requests on Qlik Cloud REST APIs. This means any API request originating to a REST API endpoint on Qlik Cloud is subject to rejection if the number of requests to an endpoint exceeds the allowed amount in a specified duration on that endpoint.
NOTE: Read on to learn more about how you may be impacted by API rate limits.
Learn more about API rate limiting at these resources:
Nebula version 3.0
The 3.0 version of Nebula has been released. It contains bug fixes, dependency updates and a few new features. Below are select updates since version 2.0
v3.0
Minor bugfixes and dependency updates.
Updated to internally use material UI v5 and React 18.
Breaking change for users of stardust/core source repository In npm package npm package
Still compatible with React 17.
Engima Mocker:
- New experimental API that allows examples and tests to run without a Qlik Sense Engine You can see source and documentation here
Improved support for qListObject in Nebula serve dev enviroment.
- Supernovas/Extensions using qListObject data works better with automated property panel.
Updated visualisations. New charts have been added and feature updates made to others. For instance:
- See New Nebula Map
- and Pivot table
- See more here .
More Options
v2.5: DisableCellPadding: reduces padding around visualistions see here
Listbox: see here
- v2.6: dense: reduces padding and text size
- v2.7: frequencyMode: Shows frequency count of values
- v2.9: checkboxes: Shows values as checkboxes.
Typescript Support
- v2.4: Typescript support
- Nebula now comes with defined types and the build command now supports visualisations that use typescript.
Read more here
AutoML Dataset Predictions
This API allows the creation and manipulation of machine learning models, and generation of predictions.
With AutoML Dataset Predictions you can:
GET/api/v1/automl-predictions/{predictionId}/coordinate-shap
: Return a file containing the shapley values in coordinate form that are associated with a predictionId.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/coordinate-shap" \
-H "Authorization: Bearer <API-key>"
POST/api/v1/automl-predictions/{predictionId}/jobs
: Retrieve jobs that are associated with a prediction.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/jobs" \
-X POST \
-H "Authorization: Bearer <API-key>"
GET/api/v1/automl-predictions/{predictionId}/predictions
: Return a file containing the predicted values that are associated with a predictionId.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-predictions/{predictionId}/predictions" \
-H "Authorization: Bearer <API-key>"
And more, see full API reference here
AutoML Real-time Predictions
With AutoML Real-time Predictions you can:
POST/api/v1/automl-deployments/{deploymentId}/realtime-predictions
: Generate predictions in a synchronous request and response.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automl-deployments/{deploymentId}/realtime-predictions" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{"schema":{"rows":[],"schema":[{"name":"string"}]}}'
See API reference here.
Lineage
The Lineage API enables users to keep track of the origins and impacted content of the base objects on resource, table, and field levels.
Additionally, the Lineage API supports search, expansion, and overview on the nodes within input and output graphs.
With this API you can:
GET/v1/lineage-graphs/nodes/{id}
: Returns a lineage graph of a source node.
{id}
is the QRI of the base node
curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/nodes/{id}" \
-H "Authorization: Bearer <API-key>"
GET/v1/lineage-graphs/impact/{id}/source
: Returns all levels of the requested root node.{id}
is the QRI of the base node
curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/impact/{id}/source" \
-H "Authorization: Bearer <API-key>"
POST/v1/lineage-graphs/nodes/{id}/overview
: Update lineage flag for this request.{id}
is the QRI of the base node
curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/nodes/{id}/overview" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"":[]
}'
GET/v1/lineage-graphs/impact/{id}/overview
: Returns all resource level nodes that are impacted by a change in the source node.{id}
is the QRI of the base node
curl "https://your-tenant.us.qlikcloud.com/api/v1/lineage-graphs/impact/{id}/overview" \
-H "Authorization: Bearer <API-key>"
And more, see full API reference here
You can also read more in this tutorial
Reload tasks
Reload-tasks are the resources of reload tasks. With this API you can:
GET/v1/reload-tasks
: Find and return the tasks that the user can access.
curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks" \
-H "Authorization: Bearer <API-key>"
POST/v1/reload-tasks
: Create a task for a specified app.
curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"appId": "116dbfae-7fb9-4983-8e23-5ccd8c508722",
"partial": true,
"timeZone": "string",
"autoReload": true,
"recurrence":
[
"FREQ=DAILY;BYHOUR=8;BYMINUTE=0;BYSECOND=0",
"FREQ=WEEKLY;BYHOUR=10;BYMINUTE=0;BYSECOND=0"
],
"endDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
"startDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
"autoReloadPartial": true,
"type": "scheduled_reload"
}'
PUT/v1/reload-tasks/{taskId}
: Update an existing task.
curl "https://your-tenant.us.qlikcloud.com/api/v1/reload-tasks/{taskId}" \
-X PUT \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"appId": "116dbfae-7fb9-4983-8e23-5ccd8c508722",
"partial": true,
"timeZone": "string",
"autoReload": true,
"recurrence":
[
"FREQ=DAILY;BYHOUR=8;BYMINUTE=0;BYSECOND=0",
"FREQ=WEEKLY;BYHOUR=10;BYMINUTE=0;BYSECOND=0"
],
"endDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
"startDateTime": "2018-11-09 14:46:07.697 +0000 UTC",
"autoReloadPartial": true,
"state": "Disabled"
}'
See full API reference here
The /evaluations
API, used to queue evaluations of Sense apps and retrieve
various performance metrics, is being deprecated in favor of new API endpoints
more consistent with the rest of the Qlik Cloud platform. The affected API endpoints are:
- POST
/v1/evaluations
- GET
/v1/evaluations
- GET
/v1/evaluations/{id}
- GET
/v1/evaluations/{id}/download
- GET
/v1/evaluations/{baseid}/compare/{comparisonid}
- GET
/v1/evaluations/{baseid}/compare/{comparisonid}/download
Migrating to the new endpoints
The capability is not being removed, and the full list of new endpoints can be found on the API reference page for apps.
In summary, the notable changes to the capability except for new paths are:
- The response body for listing evaluations now uses
response.data
like other REST APIs, instead ofresponse.evaluations
- The response body
links
field is now aligned with other REST APIs,links.next
is renamed tolinks.next.href
,links.prev
is renamed tolinks.prev.href
- The download endpoints are now action endpoints;
GET
/v1/evaluations/{id}/download
is replaced by GET/v1/apps/{id}/actions/download
and GET/v1/evaluations/{id}/compare/{comparisonid}/download
is replaced by GET/v1/apps/{id}/actions/compare/{comparisonid}/actions/download
- A few fields were dropped as they were either deemed redundant, (technically) unused,
or may cause confusion:
spaceId
userId
maxMemoryMiB
appOpenTimeSeconds
dataModelSizeMiB
sheetTitle
responseTimeSeconds2
cardinal
total_count
no_of_rows
fileSizeMiB
More information regarding how Qlik deprecates APIs can be found in the API policy.
Changes in v2.15.0
Support for the new automation API with the
automation
command# get an automation qlik automation get <automationId> # list automation runs qlik automation run ls --automationId <automationId>
See the command documentation here
Fix: Fail before request on missing path parameter
qlik item update itemId --file ./my_file # now output an explicit error message about required parameters Error: required flag(s) "resourceType" not set
Fix: correct output when using the
--json
for errorsqlik extension get don_t_exists --json # now outputs json ready to be parsed { "status": 404, "title": "Not found" }
Web-integrations
A web integration is a resource representing a list of whitelisted origins that can make requests to a specified tenant. It is the implementation of the CORS mechanism within Qlik Sense SaaS.
With this API you can;
POST/web-integrations
: Creates a web integration.
curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{"name":"My Web Integration","validOrigins":["https://thirdPartyApp.com"]}'
GET/web-integrations/{id}
: Retrieves a single web integration by ID.
curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations/{id}" \
-H "Authorization: Bearer <API-key>"
DELETE/web-integrations/{id}
: Deletes a single web integration by ID.
curl "https://your-tenant.us.qlikcloud.com/api/v1/web-integrations/{id}" \
-X DELETE \
-H "Authorization: Bearer <API-key>"
And more, see full API reference here
CSRF Token
This API is used to interact with the CSRF token resource in Edge Auth in Qlik elastic environments.
GET/csrf-token
: Returns CSRF token via the qlik-csrf-token header.
curl "https://your-tenant.us.qlikcloud.com/api/v1/csrf-token" \
-H "Authorization: Bearer <API-key>"
See API reference here
Tenants
Tenants is the resource representing a tenant.
POST/tenants
: Creates a tenant.
curl "https://your-tenant.us.qlikcloud.com/api/v1/tenants" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{"licenseKey":"string"}'
See API reference here
2.14.3
- New: Commands have been updated to reflect the latest API changes.
New API: Users
Updated: Spaces
Updated: Collections
New: OAuth 2.0 machine-to-machine support. Users are now able to authorize with Qlik Cloud SaaS over client credentials flow.
New: Added command for tenant creation.
qlik tenant create
Note: This only works with specific entitlements
such as an active subscription with the multiple tenants entitlement.
- New: Added commands for web-integrations management. Web-integrations enable users to manage whitelisted origins that can make requests to a specified tenant (CORS).
qlik web-integration create --name myAllowList --validOrigins "https://www.google.com"
# returns a web-integration id
{
"created": "...",
"createdBy": "***********mSUL6MIzchD_",
"id": "DSghcTBrzTkJBCN53IjQatRUWIJkvbno",
"lastUpdated": "...",
"name": "myQllowList",
"tenantId": "**********PMZOEbLC9z52Op_G",
"validOrigins": [ "https://www.google.com" ]
}
- New: Added commands for groups and roles management.
qlik role ls | jq '.[] | select(.name | contains("AnalyticsAdmin"))'
# returns object with role permission for AnalyticsAdmin
{
"createdAt": "...",
"description": "...",
"id": "********36af85d",
"lastUpdatedAt": "...",
"level": "admin",
"name": "AnalyticsAdmin",
"permissions": [...]
}
qlik group ls
# fetch existing groups
[
{
"createdAt": "...",
"id": "*********df6c8fc0b36c",
"lastUpdatedAt": "...",
"name": "Administrators",
"status": "active",
"tenantId": "*****OVEWVPMZOEbLC9z52Op_G"
},
...
]
To update to new version, use the command
qlik update
previous version updates:
2.13.0
- Fix: Added qlik-cli to User-Agent header
- Fix: Creating IdP fo type JWTAuth now works
identity-provider create jwtauth
Click to view full changelog updates
NEW API: Roles
You're now able to list all assignable roles within your tenant.
curl "https://your-tenant.us.qlikcloud.com/api/v1/roles" \
-H "Authorization: Bearer <API-key>"
# Http 200 - Ok
{
"data": [
{
"id": "605a18af2ab08cdbfad09259",
"tenantId": "",
"name": "AnalyticsAdmin",
"description": "",
"type": "default",
"level": "admin",
"permissions": [
"automation:delete",
"automation:disable",
"automation:enable",
"automation:list",
...
],
"createdAt": "2021-03-23T16:34:55.401Z",
"lastUpdatedAt": "2022-04-29T12:06:44.246Z",
"links": {
"self": {
"href": "https://your-tenant.us.qlikcloud.com/api/v1/roles/605a18af2ab08cdbfad09259"
}
}
},
...
]
}
For the complete list of supported features, please see the Roles API specifications.
NEW API: Groups
You're now able to view groups within your tenant.
curl "https://your-tenant.us.qlikcloud.com/api/v1/groups" \
-H "Authorization: Bearer <API-key>"
# Http 200 - Ok
{
"data": [
{
"id": "603e591b00d28755ad41bd3b",
"tenantId": "kg1knZuzosd7LR-CfvV7====tenantID",
"createdAt": "2021-03-02T15:26:19.724Z",
"lastUpdatedAt": "2021-03-02T15:26:19.724Z",
"name": "Finance",
"status": "active",
"assignedRoles": [
{
"id": "60804cf8a77b649c66733f65",
"name": "Developer",
"type": "default",
"level": "user"
}
],
"links": {
"self": {
"href": "https://your-tenant.us.qlikcloud.com/api/v1/groups/603e591b00d28755ad41bd3b"
}
}
},
...
]
}
For the complete list of supported features, please see the Groups API specifications.
API DEPRECATIONS: Users
With the release of the new roles and groups APIs, a set of users features are being deprecated. As of November 1, 2022 they will no longer be available. Please ensure to follow the migrations to avoid any downtime.
ENDPOINT: GET /users/metadata
Support for this endpoint is being removed. The role names can now be retrieved from the list roles endpoint.
ATTRIBUTE: roles
Support for user.roles
is being removed and replaced with user.assignedRoles
. Each assigned role reference
maps to an instance of a role object.
curl "https://your-tenant.us.qlikcloud.com/api/v1/users/me" \
-H "Authorization: Bearer <API-key>"
# Http 200 - Ok
{
...
"roles": [
"TenantAdmin",
"Developer",
],
"assignedRoles": [
{
"id": "60804cf8a77b649c66733f60",
"name": "TenantAdmin",
"type": "default",
"level": "admin"
},
{
"id": "60804cf8a77b649c66733f65",
"name": "Developer",
"type": "default",
"level": "user"
}
]
}
ATTRIBUTE: created
, lastUpdated
The attributes created
and lastUpdated
are being renamed to createdAt
and lastUpdatedAt
respectively.
PATCH OPERATIONS & PATHS VALUES
Support for the operations set
, unset
and add
are being removed. It's recommended to use the operation replace
for
modifying the assigned roles.
Additionally, the path /roles
is being deprecated in favor of using /assignedRoles
curl "https://your-tenant.us.qlikcloud.com/api/v1/users/123456789012345678901234" \
-X PATCH \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '[
{
"op": "replace",
"path": "/assignedRoles",
"value": [
{ "id": "60804cf8a77b649c66733f60" },
{ "id": "60804cf8a77b649c66733f65" }
]
]'
# Http 204 - No Content
SORTING
Support for the sorting attributes sortBy
and sortOrder
is being removed and replaced with sort
.
This query parameter can be prefixed with +/-
to indicate the sort order.
Examples:
sort=+name
sort=-name
sort=name
PAGINATION
The pagination query parameters startingAfter
and endingBefore
are being renamed to next
and prev
respectively.
QUERY PARAMETER: tenantId
The query parameter tenantId
is no longer required and will default to the tenant being accessed.
QUERY PARAMETER: subject
, email
, status
, role
These four user attributes are no longer supported as query paremeters when querying users.
curl "https://your-tenant.us.qlikcloud.com/api/v1/users?subject=1234567890&email=john.smith@corp.example&status=active" \
-H "Authorization: Bearer <API-key>"
You can now perform the same query using the filter
query parameter.
curl "https://your-tenant.us.qlikcloud.com/api/v1/users?filter=subject eq "1234567890" and email eq "john.smith@corp.example" and status eq "active" \
-H "Authorization: Bearer <API-key>"
For more complex filtering, you can optionally use the new filter endpoint.
curl "https://your-tenant.us.qlikcloud.com/api/v1/users/actions/filter" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"filter": "subject eq \"1234567890\""
}'
For the complete list of supported features, please see the Users API specifications.
Introducing Qlik Application Automation
Happy to announce the release of a new API: Qlik Application Automation.
Qlik Application Automation is a visual no-code approach to connecting applications. The API helps you easily build automated analytics and data workflows.
Examples
Here are a few examples of what you can expect to do with the Qlik Application Automation API:
- Create an automation.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automations" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"name":"string",
"description":"string",
"workspace":{},
"state":"available",
"schedules":[
{
"startAt":"2022-01-01 00:00:00",
"stopAt":"2022-12-01 00:00:00",
"interval":30,
"timezone":"Europe/Stockholm"
}
]
}'
- Enable an automation.
- Retrieve and update automation settings.
- Copy an automation.
- Create a run.
curl "https://your-tenant.us.qlikcloud.com/api/v1/automations/{id}/runs" \
-X POST \
-H "Authorization: Bearer <API-key>" \
-H "Content-type: application/json" \
-d '{
"id":"automationID",
"context":"editor",
"inputs":{}
}'
- Retrieves a run.
- Retry a run
- Stop running an automation
- Export a run
- Move automation to another user
For more information you can see API reference
Engine RPC
Two new methods are added to the Engine RPC.
GetFieldsResourceIds
that returns a list of resource ids (QRI) for fields that belongs to the data model. Key fields (that belongs to multiple tables), returns one resource identifier per table. Read more hereGetFieldsFromExpression
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.


Platform SDK package
As more & more developers integrate & embed Qlik Sense, the need to simplify the development process is paramount. Announcing the new Qlik Platform SDK - a suite of tools, libraries, and documentation that simplifies building high-quality and performant applications on top of the Qlik Sense Platform. The idea is to let developers extend solutions without the need to develop them from scratch.
And the best part? The capabilities of the SDK comes in two programming languages - TypeScript & Python. With TypeScript, you will have improved definitions and enhanced developer experience with modern IDEs and the Python package opens up a whole new scope for the Python developer community to leverage the power of Qlik Cloud APIs.
Looking to get started? Here are the package links:
- TypeScript - https://www.npmjs.com/package/@qlik/sdk#list-of-modules
- Python - https://pypi.org/project/qlik-sdk/#description
Please note that the Platform SDK packages are early development releases. So, please expect breaking changes as it updates and stabilize.
Data Connections API
Two new endpoints are added to the Data Connections API.
data-connections/actions/delete
that deletes multiple connections and is only available to Admins.data-connections/actions/update
that updates multiple connections and is only available to Admins.
Learn more about this here
Reloads API
The following endpoints are new to the Reloads API.
GET /reloads
: Reloads allows for triggering reloads of apps to refresh its data. Traditionally this has only been possible through the JSON-RPC websocket API, but can now also be done by using this REST API.GET /reloads/{reloadId}
: Finds and returns a reload record.POST /reloads
: Reloads an app specified by an app ID.
Read more here
Reporting Service API
The new Reporting Service API provides the ability to generate reports in PNG, PDF, and xlsx formats programmatically. Reports content could be either a single visualization, an entire sheet, a story or a composition of sheets.
Comprises two endpoints:
POST/reports
: Queues a new report request generationGET/reports/{id}/status
: Gets report request processing status
Learn more here
2.6.0
New: Added
qlik edit
command - you can now easily update resources without worrying about the complicated JSON Patch calculations. Based on theEDITOR
environment variable, the edit command starts your preferred editor automatically and once your changes are saved, allPUT
/PATCH
operations are automatically done.*If you want to see communication details for your edit call, you can use the `--verbose` flag. It displays all HTTP operations that are performed including payloads for requests.* example: ```bash qlik webhook edit <webhookId> # this command launches your preferred editor containing the resource in json format # changing, for example, the description parameter is the equivalent of doing # a patch request with payload: # [ # { # "op": "replace", # "path": "/description", # "value": "my new description" # } # ] ```
New: Added
qlik spec get
provides more detailed information about added external specs, most notably the path to the added specification.New: The auto-generated usage documentation now get automatically published to
qlik-cli upon new releases.Fix: Improved robustness in handling of array subtypes - missing types now return errors. Any included schema is thus required to have proper types defined. Previously, it defaulted to string if the type was missing.
A new tutorial for authorizing sessions to Qlik Cloud using JSON web tokens (JWT) is now available on qlik.dev named Implement JWT Authorization.
You can learn more by clicking the link preceding or reviewing the online live example qlik-cloud-jwt.
Nebula Documentation
Nebula CLI is the main entry point to start making a nebula visualization, enabling a local development server, and building extensions and mashups.
The Nebula CLI now has updated and detailed documentation updates specifically on the following
Nebula serve
Allows to run a nebula visualization with a local web development server.
nebula serve
For more details read here
Nebula build
Used to build a nebula visualization bundle.
nebula build
Read more here
Nebula sense
Used to generate Qlik Sense specific files to use a nebula visualization as an extension.
nebula sense
Learn more about this here
Nebula Charts
While nebula.js provides capabilities & APIs to build mashups and custom visualizations, it's primary purpose is often to display Qlik developed charts. These charts are available through npm under the @nebula.js scope. Learn more about it [here].
Core packages
The new core build allows to significantly reduce the size of bundle, thus bringing down the overhead of downloading large amount of codes to be run. Refer to an example here
Nebula API
nebula.js API has the following new updates:
new useEmbed hook
The useEmbed hook allows access to the Nebula instance inside a chart, for adding charts into charts. Read the API specs.
new useKeyboard hook
The useKeyboard hook enables mashups to do sense-client style keyboard navigation across chart objects. Read the API specs.
new option for Field-listbox
You can now alter property definition for Field-listbox.
Evaluations API
The Evaluations API now includes a new endpoint /evaluations/{id}/download
that allows you to download a detailed XML log for your evaluation. Learn more
about this here
Items API
When fetching items using the Items API, you now have the ability to filter
by three new subtype resources - automation
, dataset
, and dataasset
.
Additionally, if you want to speed up response time, you can now omit the
actions array from the response by setting the noActionParam
to true.
This ensures that the actions for each item is not evaluated.
New Natural Language API
The new Natural language API (/questions/actions/ask
) enables you to ask
questions and context aware partial questions against applications enabled
for conversational analytics or a specific app to receive Insight Advisor
generated responses and suggestions.
Learn more about creating customized conversational analytics interfaces
Users API
In the User
definition `created`, `lastUpdated` and `roles` fields have been deprecated.JSON engine RPC
A new experimental method Doc.SearchValues
has been added to the Qlik
Associative Engine. For more details read here
The latest version of qlik-cli
allows better windows support, support for
new APIs and notifications.
Here are the updates.
Chocolatey
qlik-cli is now back to Chocolatey
To install using choco
:
choco install qlik-cli
To upgrade qlik-cli using chocolatey:
choco upgrade qlik-cli
If you see an error like below:
Error retrieving packages from source The combination of parameters provided to this OData endpoint is no longer supported. Please refer to the this URL for more information about this deprecation.
Then first run:
choco source list
Then remove the one matching nuget.org:
choco source rm --name=nuget.org
Another way to fix a failing upgrade is to uninstall and reinstall.
choco uninstall qlik-cli
choco install qlik-cli
in v2.5.0 / v2.5.1
New - Added support for outbound proxy: you can now set the operating system environment
variables called HTTPS_PROXY/HTTP_PROXY
with the hostname or IP address of
the proxy server.
Note: HTTPS_PROXY takes precedence over HTTP_PROXY for https requests. Qlik CLI supports only Basic Authentication.
Fix - Improve --limit flag descriptions
Fix - Updated the included latest Qlik Sense SaaS API-specifications
in v2.4.0
Updated Commands
Commands have been updated to reflect the latest API changes.
Notifications
Users to be notified when a new version of qlik-cli is available. The notification message contains URL with detailed changelog of the latest release.
Self Update CLI
The self update command enables users to update to the latest version of
qlik-cli by simply running qlik update
.
OpenAPI specs support
The latest qlik-cli update provides support for OpenAPI specs that define parameters at the path level. In this case, the parameters are inherited by all operations under that path.
Progress Bar
The animated progress bar displayed when uploading an app is now based on estimated upload time.
Support for unix-like Windows terminals
The latest version of qlik-cli provides better support for unix-like Windows terminals (such as MingGW, MSYS2, and Cygwin).
Fix
The latest version of qlik-cli also includes bug fixes and minor improvements.
in v2.3.0
Support for identity-providers endpoint
The identity-providers
service is used for managing identity providers.
In this version of qlik-cli the support for identity-providers endpoint is provied.
Support for questions endpoint
The questions
endpoint lets user ask natural language questions against
Qlik Sense apps enabled for conversational analytics. This version of qlik-cli
provides support for this endpoint.
qlik question ask --app-id <appId> --text="new cases by department over time"
#returns a QueryResponse object containing conversational response
{
...
"conversationalResponse": {
...
"responses": [
{
"imageUrl": "/api/v1/temp-contents/6139c949f0ccf200019a09e2?inline=1",
"sentence": {
"text": "new cases by department over time"
},
"type": "chart"
},
{
"narrative": {
"text": "* New Cases is 180.\n* There were 18 of New Cases not associated to a Department. This may indicate a data quality issue."
},
"sentence": {
"text": "new cases by department over time"
},
"type": "narrative"
}
],
"sentenceWithMatches": "**new cases** by **department** over time"
},
Progress bar for Downloads
The latest version of qlik-cli also shows an animated progress during app download.
Spinner feedback
A new spinner feedback is added when users are waiting for server response using qlik-cli.
Client family API updates
Single Integration 1.2.1
Updated descriptions for URL parameters
App Integration 1.1.1
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 Sense SaaS 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 latest version of qlik-cli adds resumable uploads for large Qlik Sense applications and bug fixes to improve overall usability. Here are the updates.
New feature highlights
Import large Qlik Sense apps
You can now upload large apps to SaaS tenants using qlik-cli using the qlik app import
command. Use the --resumable
switch to instruct the cli to handle the upload as a large file.
When you upload an app using qlik-cli, a nice animated bar appears displaying the progress.
File piping
File piping allows you to combine commands where the output of one may be used as the input of the next command you issue.
Command aliases
Aliases enable you to create shorthand commands for hard to remember long
commands. For example, say you run a command frequently to find the guid of an
application in your tenant, $(qlik item ls --resourceType app --name
. You can
use the alias command to create a shortcut it into something like
qlik getAppGuid consumer+sales
. This returns the complete JSON object for the
consumer+sales resource in the items collection.
Limit flag added for listing apps
The --limit
switch enables you to return a number of app resource objects per
page ranging from 1 to 100.
Identifying experimental flags and switches in commands
Command switches and flags that are experimental features are labeled as such for your information.
Fixes worth mentioning
Temporary Upload Service
Use of the temporary upload service in qlik-cli caused problems with large app
uploads and resumability. This problem has been fixed and implemented through
the resumable switch in the qlik app import
command.
Updated response from reload get command
In prior CLI versions, qlik reload get
was not sending a correct response.
This issue has been resolved.
Bullet list of all features and fixes in qlik-cli 2.2.0
feature: add limit flag when listing apps
feature: Support resumable uploads
feature: add status for qseow
feature: Support big apps
feature: show if a flag or command is experimental
feature: Add progress-bar
feature: add support for command aliases
feature: Add Patch description
feature: support for files piping
fix: Solve temporary upload service store issues
fix: Add timeout to Establish TCP connection
fix: append exprimental to long description with leading newline
fix: Honor optional request bodies
fix: handle empty stdin
fix: omit cookie header
fix: updated response for reload get
Update qlik-cli today by using brew if you use a Mac, or download the redistributable from here.
New Evaluation API Property - fileSizeMiB
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.
Learn more about optimizing app performance and using the API in DevOps processes here.
Apps API Export App Response Update
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.
New App Evaluation API
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.
Learn more about
optimizing app performance and using the API in DevOps processes here.New commands
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.
qlik api-key ls --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.
#qlik app create command
app=$(qlik app create --attributes-name "example")
echo $app
#returns new response
{
"attributes": {
"_resourcetype": "app",
"createdDate": "2021-02-15T07:01:43.930Z",
"custom": {},
"description": "",
"dynamicColor": "",
"encrypted": true,
"hasSectionAccess": false,
"id": "8be82d0f-02d2-4f0e-974c-08dc444384a7",
"lastReloadTime": "",
"modifiedDate": "2021-02-15T07:01:46.575Z",
"name": "testttt2",
"originAppId": "",
"owner": "auth0|b96eb87010c7ad52667b2dc8b1ec0b12f97c43ae7848740874267b62aa45c856",
"ownerId": "ffnbiWZyssMZ5ofRfLc1JzFdZrPvACFl",
"publishTime": "",
"published": false,
"thumbnail": ""
},
"create": [...],
"privileges": [...]
}
Instead of returning information from the items API.
#Breaking change
app=$(qlik app create --attributes-name "example")
echo $app
#returns old response
{
"actions": [...],
"collectionIds": [],
"createdAt": "2021-02-15T08:15:57Z",
"creatorId": "ffnbiWZyssMZ5ofRfLc1JzFdZrPvACFl",
"id": "602a2dbd31d6bf3d1f471c31",
"isFavorited": false,
"meta": {...},
"name": "testttt3",
"ownerId": "ffnbiWZyssMZ5ofRfLc1JzFdZrPvACFl",
"resourceAttributes": {...},
"resourceCreatedAt": "2021-02-15T08:15:57Z",
"resourceCustomAttributes": null,
"resourceId": "22205ac6-406c-4484-b715-1da12219b044",
"resourceReloadEndTime": "",
"resourceReloadStatus": "",
"resourceSize": {... },
"resourceSubType": "",
"resourceType": "app",
"resourceUpdatedAt": "2021-02-15T08:15:57Z",
"tenantId": "xrpC13FnjenBc-mhBG98ah2qNlfmwj8X",
"thumbnailId": "",
"updatedAt": "2021-02-15T08:15:57Z",
"updaterId": "ffnbiWZyssMZ5ofRfLc1JzFdZrPvACFl"
}
From now on, to obtain the unique id referencing the app in the items API, you
need to issue a qlik item ls
command after running qlik app create
.
qlik item ls --resourceId $app --resourceType app
#returns item information formerly seen in the old response
Bug fixes
- Fixed a bug with
qlik app ls
returning non-app resources. - Fixed
qlik qrs task start by-id
which failed withno such operation
message. - Resolved runtime errors using qlik-cli on Windows computers.
Subscribe to receive update notifications
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.
For more information, see the API reference here.
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"
}
Learn more about the Collections API here.
Identity Providers V1 API released public/stable
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:
- get license status
- get license overview
and three public/experimental endpoints:
- assign access to users
- delete user license assignments
- update user license assignments
Learn more about the API here.
Reloads API re-released public/stable
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).
Learn more about the API here.
qlik-cli 1.7.1 released
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.dev now with dark mode
qlik.dev supports dark mode.
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!
Check out the blog to learn more.