By Giacomo Brioschi, Principal Solution Architect, Qlik | Sathisan Vannadil, Senior Partner Solutions Architect, AWS | Sunil Yerkola, Senior Solutions Architect, ISV, AWS.

This guide walks you through the complete setup to bridge Amazon Quick and the Qlik MCP server, enabling real-time access to trusted Data Products with Qlik Trust Score for governed, AI-ready data, and insights and context from the Qlik Analytics Engine, all from within Amazon Quick.

Content

• What you'll need
• Step 1: Configure user roles for MCP access
• Step 2: Assign the new MCP role to users or groups
• Step 3: Create a new OAuth client for Amazon Quick
• Step 4: Add the Qlik MCP server as a connection in Amazon Quick
• Step 5: Create a new chat agent in Quick that uses the Qlik MCP server as an action
• Step 6: The power of Amazon Quick and the Qlik MCP server in action
• Troubleshooting
• Related Content

What you'll need

• An active AWS account
• Amazon Quick setup with user rights to create Connectors
• A Qlik Cloud tenant where you have Tenant Admin rights

Step 1: Configure user roles for MCP access

A Qlik tenant administrator must create (or update) a custom user role that grants the Qlik MCP permission. Without this, users will authenticate successfully but won't be able to execute any MCP tools.

1. In the Administration activity center, click Manage users.
2. Go to the Permissions tab and click Create new.
3. Assign a name to the role (e.g., MCP User) and under Features and actions > Agentic AI, set the MCP permission to Allowed.
4. Click Save.
   
   Setting the MCP permission to Allowed under Features and actions in a Qlik Cloud custom role
   

Step 2: Assign the new MCP role to users or groups

1. In the Administration activity center, click Manage users and go to the All users tab.
2. Click the three-dot menu (...) (A) on the right side of the user's row and select Manage roles (B).
   
   
   
   
3. Assign the MCP role to each user who needs access to the Qlik MCP server. Alternatively, you can assign the new role to a group of users.
   
   
   
   
4. Save your changes.

This can also be done from the Permissions tab. Use the Auto assign drop-down to give permission to all users in your tenant.

Space permissions and Section Access rules still apply. The MCP role grants access to the MCP server itself, but what each user can see and do through MCP is governed by their existing Qlik Cloud permissions. See Qlik MCP server access and permissions for details.

Step 3: Create a new OAuth client for Amazon Quick

The OAuth client authenticates and scopes user access when Quick connects to the Qlik MCP server. A tenant administrator must create an OAuth client for the integration. Once the OAuth client is ready, you can add the Qlik MCP server as a connection in Quick.

Alternatively, you can use OAuth Dynamic Client Registration (DCR), which allows an LLM client to register itself automatically with Qlik Cloud, without the tenant administrator needing to create an OAuth client in advance.

For more information, see how to connect to the Qlik MCP server and how to create OAuth clients for LLM clients in our online help.

Amazon Quick supports two OAuth client types for User authentication: Web (server-side, browser-based redirect flow) and Native (client-side, PKCE-based flow without a backend secret). Choose the one that best fits your security requirements and use case. The following section describes the Web configuration as an example.

1. In your Qlik Cloud tenant, navigate to the Administration activity center.
2. Go to OAuth and click Create new.
3. For the Client type, select Web.
4. Enter a name for the OAuth client (e.g., Amazon Quick MCP) and optionally add a description.
5. Under Scopes, select user_default and mcp:execute.
   
   
   
   Optionally add offline_access to reduce re-authentication frequency to once every 30 days from the default 6-hour expiry.
   
   
6. Under Add redirect URLs, enter the authentication callback URL for Quick as a redirect URI: https://{region}.quicksight.aws.amazon.com/sn/oauthcallback. Replace {region} with your AWS Region (for example, us-east-1).
   
   
   
   
7. Click Create.
8. Immediately copy the Client ID and Client Secret; you'll need both in the next step to configure the integration on the Amazon Quick side, and the secret won't be shown again.

Important, tenant admin must connect first: according to Qlik documentation, the tenant administrator has to be the first user to connect and authenticate with any new MCP client. This establishes tenant level trust between Quick and the Qlik OAuth app. Until the admin completes this first connection, other users' connection attempts will fail. Make sure the admin completes the Quick side integration (Step 4) and authenticates before rolling out access to other users.

Step 4: Add the Qlik MCP server as a connection in Amazon Quick

This step is performed in Amazon Quick, not in Qlik Cloud.

In this final configuration step, you will create an Amazon Quick connection to the Qlik MCP server to access your trusted data foundation. Once this is completed, you will be able to use your Amazon Quick Chat Agents to invoke the available tools to retrieve insights from Qlik. Instructions for adding a remote MCP server connection in Quick will depend on the Quick integration UI.

At a high level:

1. Sign in to Amazon Quick using your web browser.
2. Go to More on the sidebar menu, select Connectors, and click Model Context Protocol within the list of supported connectors.
3. On the Create integration screen, enter the Name and Description for your Qlik MCP integration. For the MCP server endpoint, enter the URL of the Qlik MCP server as https://{your-tenant-hostname}.{your-tenant-region}.qlikcloud.com/api/ai/mcp, as shown in the screenshot below, and make sure to replace {your-tenant-hostname} and {your-tenant-region} with the hostname and region of your Qlik Cloud tenant.
   
   
   
   
4. Choose Next once you're done.
5. In the following Authenticate screen, select User Authentication as the Authentication method, Custom user based OAuth as the Auth Configuration, and enter the following details:
   1. Enter the Client ID and Client Secret that you previously copied from the Qlik OAuth client you created in Step 3. If you chose Native as the OAuth client type, leave Client secret empty.
   2. Token URL allows a client to perform an OAuth flow with Qlik to obtain a token set. Enter your token URL as https://{your-tenant-hostname}.{your-tenant-region}.qlikcloud.com/oauth/token, replacing your-tenant-hostname and your-tenant-region with the hostname and region of your Qlik Cloud tenant. 
   3. The Authorization URL is the URL that the MCP server uses to retrieve the authorization token. Enter your Authorization URL as https://{your-tenant-hostname}.{your-tenant-region}.qlikcloud.com/oauth/authorize, again replacing the tenant hostname and region placeholders.
      
      
      
      
6. Click Create and Continue.
7. Authenticate by signing into your Qlik Cloud tenant when prompted.
8. Click Approve to authorise Quick to access your Qlik Cloud data.

   Data sharing notice: by clicking Approve, you enable the Qlik MCP server to share your Qlik Cloud data with Amazon Quick. Quick is not managed by Qlik, and your data will be stored and processed under AWS's control. Check your organisation's AI data sharing policies before proceeding.

   
   
   
9. In Manage Tools & Permissions, you can list the tools available for read and write operations, and in the final section, Publishing the connection, you have the option to share this connection with your team members, e.g., with users or a group of users who can access the Qlik MCP server via Amazon Quick.
   
   In this example, the connection has been shared with a group called Qlik Test.
   
   
   
   
10. Click Publish to create the connection.
11. If the integration creation has been successful, you should be able to see the list of actions (tools) available within the connector, as shown in the snapshot below:
    
    
    
    For a complete list of Qlik tools available, see Qlik MCP tools | help.qlik.com.

Step 5: Create a new chat agent in Quick that uses the Qlik MCP server as an action

With the connector in place, the tools that the Qlik MCP server provides are now available within Amazon Quick. Chat Agents in Amazon Quick help users explore data, analyse information, and take actions through open-ended natural language conversations, now including Qlik's capabilities. Agents are configured with specific goals, knowledge sources, and connected tools, and can evolve from simple question answering to orchestrating complex workflows. You can use chat agents to:

• Generate content and provide answers through natural language conversations
• Analyse and summarise information from connected spaces, dashboards, topics, datasets, and uploaded files
• Invoke actions to perform predefined steps for consistent, repeatable outcomes

For more information, see Create, customize, and deploy AI-powered chat agents in Amazon Quick | docs.aws.

Let's explore together how to create an Agent in Amazon Quick that uses the Qlik MCP server connection.

1. When you are in Amazon Quick, go to More on the left sidebar and click Chat Agents, then select Create a chat agent from the central part of the UI.
   
   
   
   
2. Describe in your own words how you want the agent to behave; Amazon Quick will use that to automate the setup for you. This step is optional and can be skipped in favour of manual configuration.
3. In the Configure chat agent window, make sure that within Actions, the Qlik MCP integration connection configured in Step 3 of this guide is linked; otherwise, link it manually.
4. Once you're done, click Launch chat agent.
   
   

Step 6: The power of Amazon Quick and the Qlik MCP server in action

Now you're ready to harness the full power of Qlik's trusted Data Products and Analytics Engine within Amazon Quick workflows through the newly created agent. What once required switching between tools can now happen in a single, unified experience.

Troubleshooting

Problem: Non-admin users can't connect
Likely root cause: Tenant admin hasn't completed first connection yet (see note in Step 3)

Problem: OAuth callback fails
Likely root cause: Region placeholder in the redirect URL doesn't match your Quick instance's actual region

Problem: User connects but can't access specific apps or data
Likely root cause: Space permissions or Section Access rules are restricting access; this is by design

Problem: The user is not able to use Qlik tools from the Amazon Quick Chat Agent
Likely root cause: Make sure the Qlik MCP server connection is added to the Chat Agent's available actions

Related Content

• Deploying and administering Qlik MCP server
• Qlik MCP server access and permissions
• Connecting to the Qlik MCP server
• OAuth2 clients Qlik Cloud supports
• Integration demo

The Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external data sources and tools.

Connecting Perplexity to the Qlik MCP server means you can get Perplexity’s real-time web search and reasoning alongside Qlik’s governed analytics data in a single conversation, or have it take action to manage operations within your Qlik Cloud tenant.

What you'll need

• A Qlik Cloud tenant with the MCP server enabled by a tenant administrator. Review Deploying Qlik MCP server for a tenant for details.
• A Perplexity Pro, Max, or Enterprise account (accurate at time of writing). If using an enterprise account, you must have permission to create new connectors, or ask an administrator to help.
• Tenant administrator access in Qlik Cloud to create an OAuth client.

How the Qlik MCP server works

A short orientation before touching any settings:

• The MCP server URL follows the pattern https://<your tenant URL>/api/ai/mcp.
• All connections are user-bound: access tokens are scoped and time-limited, and data access is enforced by the same access controls as when a user uses the interface directly.

See Qlik MCP server for details.

Which OAuth client type should I use?

Before creating the OAuth client in Qlik Cloud, decide which client type fits your situation. For connecting Perplexity, the relevant choice is between Web and Native.

Web client (recommended for most organisations)

A Web client issues a client secret in addition to a client ID. The secret is stored server-side on Perplexity and is never exposed to the browser or end user. This makes it the more secure option: even if someone obtains the client ID, they cannot complete the OAuth flow without the secret.

Use a Web client when:

• You are rolling out the connector to a team or organisation and want an additional layer of credential protection.
• Your organisation’s security policy requires confidential client flows.
• You have an admin who can manage secret rotation if needed.

Copy the client secret at creation time. Qlik will not show it again. For a Web client, you will paste it into Perplexity during connector configuration.

Native client (lightweight public client)

A Native client does not use a client secret. It relies on the OAuth PKCE flow, which protects against code interception without requiring a shared secret. This is a valid and commonly used pattern for public clients.

Use a Native client when:

• You want the simplest possible setup with no secret to manage or rotate.
• Your organisation permits public client flows for internal tooling.

At a glance

Both client types work with Perplexity’s custom remote connector flow.

Step 1: Prepare the OAuth client in Qlik Cloud

The tenant administrator creates the OAuth client:

5. In the Qlik Cloud Administration activity center, go to OAuth and click Create new.
6. Select Web or Native as determined above.
7. Add the required scopes: user_default and mcp:execute.
   Optionally add offline_access to reduce re-authentication frequency to once every 30 days from the default 6-hour expiry.
8. For the redirect URL, enter Perplexity’s OAuth callback:
   
   
   • https://www.perplexity.ai/rest/connections/oauth_callback
   • For organisations on the Perplexity Enterprise subdomain, use https://enterprise.perplexity.ai/rest/connections/oauth_callback instead.
     
     See Adding Custom Remote Connectors for more details.
9. If using a Web client, copy the client secret immediately. Qlik will not show it again.
10. Note down the Client ID.

See Deploying Qlik MCP server for a tenant for details. 

Step 2: Add the connector in Perplexity

1. Go to Account settings > Connectors and click + Custom connector, then select Remote.
2. Fill in the required fields:
   • Name: Qlik Cloud (or your tenant name).
   • MCP Server URL: https://<your-hostname>.<your-region>.qlikcloud.com/api/ai/mcp
   • Authentication: OAuth 2.0. Enter the Client ID from step 1. For a Web client, also enter the Client Secret. For a Native client, leave the secret field blank.
   • Transport: Streamable HTTP.
3. Acknowledge the data-sharing warning and click Add.
4. Navigate back to the connector listing and find the new connector.
5. Click Add Connector on the connector card to start the Qlik OAuth flow, sign in to your Qlik Cloud tenant, and click Approve.

By clicking Approve, you are authorising the Qlik server to share your Qlik Cloud data with Perplexity, a third-party system not managed by Qlik. Check your organisation's AI data-sharing policies before proceeding.

If the Qlik MCP server supports OAuth discovery (via /.well-known/oauth-authorization-server), Perplexity can detect endpoints and scopes automatically, and you may not need to enter them manually.

Step 3: Enable the connector and test it

Toggle the connector on under Sources in a Perplexity thread. You can also type the connector name, and it’ll suggest adding it to the thread.

Try these example prompts to confirm the connection is working:

• “What apps are available in my Qlik Cloud tenant?”
• “Summarise the key metrics from [your data product name].”
• “What does [KPI name] look like this month compared to last?”

Organisation members can add custom remote connectors if admins have enabled them. Only admins can share a connector with the entire organisation, done from the Permissions screen in Enterprise settings.

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

Environment:

Qlik NPrinting 

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

• Connection reloads
• Publish Task executions

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

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

• GET
• POST

Requirements of REST user account:

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

Creating REST "GET" connections

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

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

Creating REST "POST" connections

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

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

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

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

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

Related Content

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

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

This article explains how to obtain a task schedule in the Talend Management Console, how to pause it, and how to resume it. All steps are performed using the API.

In the example, we use the following values:

• The Environment ID: 5b0431e2ee7c2b4082797c73
• Task ID: 698ba125c327f6c153585c67
• %TOKEN% is to be replaced by your actual bearer's token
• The API URL used in each example is set to the EU region, api.eu.cloud.talend.com. Update the region accordingly. 
• The schedule is set from: 1772628971000 to 1775220971000, which is the 3rd of March 2026 to the 3rd of April 2026 in milliseconds since January 1st 1970. Use epochconverter.com to convert date and time to epoch time. 

Content

• Getting a task schedule
• Pausing a task
• Resuming a task
• Pausing and resuming a plan

Getting a task schedule

First, we get the scheduling of a task. 

The following Qlik Talend API can be used to retrieve the executions scheduled in a time window using the "from" and "to" parameters: Get scheduled executions 

Get scheduled executions of all types

POST /orchestration/executables/events/search

Example: 

curl -v -X POST ^
-H  "Content-Type: application/json" ^
-H  "Accept: application/json" ^
-H  "Authorization: Bearer %TOKEN%" ^
-d "{\"environmentId\":\"5b0431e2ee7c2b4082797c73\",\"from\":\"1772628971000\",\"to\":\"1775220971000\"}" ^
https://api.eu.cloud.talend.com/orchestration/executables/events/search

The API returns a maximum of 100 entries by default. The parameter "offset" can be used to retrieve the next entries.

Example with "offset": 

curl -v -X POST ^
-H  "Content-Type: application/json" ^
-H  "Accept: application/json" ^
-H  "Authorization: Bearer %TOKEN%" ^
-d "{\"environmentId\":\"5b0431e2ee7c2b4082797c73\",\"from\":\"1772628971000\",\"to\":\"1775220971000\",\"offset\":100}" ^
https://api.eu.cloud.talend.com/orchestration/executables/events/search

To retrieve all the entries, increase the "offset" value to the total value returned by the call that is lower than the limit value.

Pausing a task

Next, we pause the task.

The following Qlik Talend API can be used to pause a task: Pause / Resume a Task

Pause / Resume a Task

PUT /orchestration/executables/tasks/{taskId}/pause

Example:

curl -v -X PUT ^
-H  "Content-Type: application/json" ^
-H  "Accept: application/json" ^
-H  "Authorization: Bearer %TOKEN%" ^
-d "{\"pause\":true,\"pauseContext\":\"Pause during the maintenance window\"}" ^
https://api.eu.cloud.talend.com/orchestration/executables/tasks/698ba125c327f6c153585c67/pause

Resuming a task

We now set the task to resume.

The following Qlik Talend API can be used to resume a task: Pause / Resume a Task

Pause / Resume a Task

PUT /orchestration/executables/tasks/{taskId}/pause

Example:

curl -v -X PUT ^
-H  "Content-Type: application/json" ^
-H  "Authorization: Bearer %TOKEN%" ^
-d "{\"pause\":false}" ^
https://api.eu.cloud.talend.com/orchestration/executables/tasks/698ba125c327f6c153585c67/pause

Pausing and resuming a plan

To pause and resume a plan, the following Qlik Talend API can be used: Pause-Resume Plan executions

Pause-Resume Plan executions

PUT /orchestration/executables/plans/{planId}/pause

Environment

• Qlik Talend Cloud
• Qlik Talend Management Console

When attempting to execute a Talend Management Console (TMC) task using a Service Account via the Talend Management Console API, users may encounter an HTTP 403 Forbidden response—even if the Service Account is correctly configured.

When attempting to execute a task using the Processing API endpoint:

POST https://api.<region>.cloud.talend.com/processing/executions

the API returns:

 

{  "status": 403,  "requestId": "5303a858-8849-4572-ad37-4ce42c077c41",  "message": "Forbidden" }

This issue typically arises when the necessary permissions for task execution are not granted prior to generating the service account token, or when the service account lacks specific functional permissions pertaining to task execution.

Observed behavior

The token generated via:
POST /security/oauth/token
is valid.

The Service Account permissions appear to include:

TMC_ENGINE_USE
TMC_ROLE_MANAGEMENT
TMC_SERVICE_ACCOUNT_MANAGEMENT
AUDIT_LOGS_VIEW
TMC_USER_MANAGEMENT
TMC_CLUSTER_MANAGEMENT

According to the documentation Using a service account to run tasks | Qlik Help Center, the Service Account must possess either TMCENGINEUSE or TMC_OPERATOR permissions; however, even with these permissions, the execution still fails.

Resolution

Step 1: Assign "Tasks and Plans – Edit" Permission

Navigate to Talend Management Console→ Users & Security → Service Accounts, and ensure the Service Account has the permission: Tasks and Plans – Edit

Step 2: Regenerate the Service Account Token

After updating permissions, regenerate service account Token.

This ensures that the token contains the updated permission set. Subsequently, rerunning the task via the API will work.

Environment

• Talend Cloud 

To retrieve the task with the status "Misfired" via API, you can use the API "/monitoring/observability/executions/search" mentioned below:

#type_searchrequest | talend.qlik.dev .

However, EXECUTION_MISFIRED status returned only if "exclude=TASK_EXECUTIONS_TRIGGERED_BY_PLAN"

So if you want to return any plans or tasks that are misfired, you should send this filter request:

 "filters": [  {  "field": "status",  "operator": "in",  "value": [  "DEPLOY_FAILED",  "EXECUTION_MISFIRED"  

Example

URL: https://api.<region>.cloud.talend.com/monitoring/observability/executions/search

{
    "environmentId": "123456......",
    "category": "ETL",
    "filters": [
        {
            "field": "status",
            "operator": "in",
            "value": [
                "DEPLOY_FAILED",
                "EXECUTION_MISFIRED"
            ]
        }
    ],
    "limit": 50,
    "offset": 0,
    "exclude": "TASK_EXECUTIONS_TRIGGERED_BY_PLAN"
}

Internal Investigation ID(s) 

Jira ID: SUPPORT-7251

Environment

• Talend ESB 
• #Talend Cloud API

In Qlik Sense Enterprise on Windows, using QRS API '/qrs/App/table' by providing a body returns more than expected rows. 

Example: 

1. Using POSTMAN, we perform a POST call including the body:
   
   
   
   
2. With the above body, we expect that the response rows would ONLY contain name, id, and values as defined above in "list":
   
   
   
   
3. However, this POST request returns more than the requested rows, such as id, name, valueType, choiceValues, and privileges:
   
   

Resolution

This behavior has been identified as defect SUPPORT-6127.

It is caused by the default value of the parameter HideCustomPropertyDefinition set to true in the Repository.exe.config file. Changing the parameter from true to false resolves it.

To change the value: 

1. Navigate to C:\Program Files\Qlik\Sense\Repository\ and locate Repository.exe.config
2. Open Repository.exe.config in a text editor
3. Find HideCustomPropertyDefinition and set its value from true to false
   If you are running a multi node environment, make the change on each node. 
4. Save the Repository.exe.config file‘false’

Cause

Issue related to the default configuration setting of the parameter HideCustomPropertyDefinition in the Repository.exe.config file.

Internal Investigation ID(s)

SUPPORT-6127

Environment

• Qlik Sense Enterprise on Windows

When Stitch replicates data from SaaS sources, it must operate within the API rate limits defined by each vendor. These limits determine how many API requests can be made within a specific time period to prevent server overload. Exceeding them typically results in rate limit errors (most often HTTP 429 responses), which can temporarily interrupt data replication.

This article outlines common API rate limit errors observed in Stitch integrations and provides best practices to help you minimize and handle these limits for reliable data replication.

Known API Rate Limit Errors

The exact error message for exceeding API rate limits varies across platforms, but all indicate the same underlying cause — too many API requests made within a defined time window.

Refer to the table below for examples of rate limit errors observed in popular Stitch SaaS integrations | Stitch Documentation:

Stitch recommendations & solutions for rate limit errors

• Reduce replication frequency of an integration if extractions frequently exceed the API’s rate limit.

• Stagger replication frequency schedules for multiple integrations that connect to the same source account to reduce the number of concurrent calls.

• Use the key-based incremental replication method | Stitch Documentation where available:
  
  Full Table Replication: Extracts all data from the Start Date indicated in the integration settings during every extraction. This usually requires many API calls as most integrations use pagination to retrieve data.
  Incremental Replication: Only fetches new or changed records since the last successful sync, based on a bookmark value. 
  Incremental replication can reduce API call volume by extracting less data, thereby reducing the number of API calls that would need to be made.

• Monitor extraction logs in Stitch for frequent 429 errors.

• Contact the API provider to request increased rate limits where applicable.

• Contact Qlik Support if needed.

Environment

• Stitch 

During the extraction process of your HubSpot integration, the following error was encountered:

requests.exceptions.HTTPError: 500 Server Error: Internal Server Error for url <CustomURL>

...

Giving up on request after {} tries with url {} and params {}

Resolution

This error may be transient. However, if it is recurring frequently enough to disrupt your workflow, please reach out to Qlik Support.

Cause 

The HubSpot API is having issues processing the amount of data compiled based on the request sent by Stitch.

Environment

• Stitch 

Question

How can we retrieve artifact information from Talend update website? For instance, for artifact "accessors-smart-2.4.11.jar", we can use the following URL to query its information: https://search.maven.org/solrsearch/select?q=a:accessors-smart+AND+v:2.4.11&rows=1&wt=json

Does Talend also offer a similar feature for its artifacts?

Answer

Talend update website is built on Nexus and utilizes the Lucene search API, as demonstrated in the following example:

https://talend-update.talend.com/nexus/service/local/lucene/search?a=accessors-smart&v=2.4.11

For further details on the Lucene search API, please refer to: Nexus Indexer Lucene Plugin REST API | repository.sonatype.org

Environment

• Talend Data Integration 

Question

 I would like to get a full list of integrations and configuration details of those integrations. Things like the list of tables we are syncing, the schedule it is being synced on, etc.

Can you provide a way to let Stitch users export the details of the integrations in one file? It should show the list of tables replicated, replication frequency, the integration settings to show how its configured.

You can accomplish this with the Qlik Talend Cloud Migration Toolkit: stitch-assets-inventory | Qlik Help

Alternatively, if you have an Advanced or Premium subscription you can leverage Stitch's Connect API to obtain metadata on your account:

Stitch Connect API Reference# API functionality (Qlik Stitch Documentation)

For any details not available in the above, please submit a feature request via qlik-product-insight

Environment

Stitch 

Google Ads extractions fail with:

tap - CRITICAL 504 Deadline Exceeded
tap - grpc._channel._InactiveRpcError: <_InactiveRpcError of RPC that terminated with:
tap - status = StatusCode.DEADLINE_EXCEEDED
tap - details = "Deadline Exceeded"
tap - debug_error_string = "UNKNOWN:Error received from peer {grpc_status:4, grpc_message:"Deadline Exceeded"}"
tap - >

main - INFO Exit status is: Discovery succeeded. Tap failed with code 1 and error message: "504 Deadline Exceeded". Target succeeded.

Resolution

This error is often transient and will not require any action to alleviate. If the error is persistent, review your Tables to Replicate and consider de-selecting unneeded tables or columns. If the issue remains, please reach out to Qlik Support to discuss your use-case and further review the integration settings.

Cause

The error "504 Deadline Exceeded" indicates that the extraction timed out due to a lack of response from the Google Ads API. By default, Stitch allows up to 15 minutes for a response before terminating the request.

Possible reasons the Google Ads API may exceed this threshold include:

• Large or complex queries: This can happen when Stitch issues requests with a wide date range, a large number of selected fields, or the source data has deeply nested data structures.
• Google Ads API Limits and Quotas| developers.google.com
• Network latency or backend delays: Delays between Stitch and Google Ads, or internal processing delays within Google Ads, can also contribute to timeouts.

Environment

Stitch 

Qlik Automate is a no-code automation and integration platform that lets you visually create automated workflows. It allows you to connect Qlik capabilities with other systems without writing code. Powered by Qlik Talend Cloud APIs, Qlik Automate enables users to create powerful automation workflows for their data pipelines.

Learn more about Qlik Automate.

In this article, you will learn how to set up Qlik Automate to deploy a Qlik Talend Cloud pipeline project across spaces or tenants.

To ease your implementation, there is a template on Qlik Automate that you can customize to fit your needs.
You will find it in the template picker: navigate to Add new → New automation → Search templates and search for ‘Deploying a Data Integration pipeline project from development to production' in the search bar, and click Use template.

ℹ️ This template wil be generally available on October 1, 2025.

Use case and pre-requisites

In this deployment use case, the development team made changes to an existing Qlik Talend Cloud (QTC) pipeline.

As the deployment owner, you will redeploy the updated pipeline project from a development space to a production space where an existing pipeline is already running.

To reproduce this workflow, you'll first need to create:

• Two data spaces:
• A DEV space
• A PROD space
• Two source databases
• A DEV source database
• A PROD source database
• Two target databases
• A DEV target database
• A PROD target database

Using separate spaces and databases ensures a clear separation of concerns and responsibilities in an organization, reduces the risk to production pipelines while the development team is working on feature changes.

Workflow steps:

1. Export the updated pipeline project from the DEV space
2. Get the project variables from DEV
3. Update the project variables for PROD before import
4. Stop the pipeline currently running in production
5. Import your project to the PROD space
6. Prepare your project and check the status
7. Restart the project in PROD

ℹ️ Note: This is a re-deployment workflow. For initial deployments, create a new project prior to proceeding with the import.

Step-by-step workflow

1. Export the updated pipeline project from the DEV space

Use the 'Export Project' block to call the corresponding API, using the ProjectID.

This will download your DEV project as a ZIP file. In Qlik Automate, you can use various cloud storage options, e.g. OneDrive. Configure the OneDrive 'Copy File on Microsoft OneDrive' block to store it at the desired location.

To avoid duplicate file names (which may casue the automation to fail) and to easily differentiate your project exports, use the 'Variable' block to define a unique prefix (such as dateTime). 

2. Get the project variables from DEV

From the 'Qlik Talend Data Integration' connector, use the 'Get Project Binding' block to call the API endpoint.

The 'bindings' are project variables that are tied to the project and can be customized for reuse in another project. Once you test-run it, store the text response for later use from the 'History' tab in the block configuration pane on the right side of the automation canvas:

3. Update the project variables for PROD before import

We will now use the 'bindings' from the previous step as a template to adjust the values for your PROD pipeline project, before proceeding with the import.

From the automation, use the 'Update Project Bindings' block. Copy the response from the 'Get Project Binding' block into the text editor and update the DEV values with the appropriate PROD variables (such as the source and target databases). Then, paste the updated text into the Variables input parameter of the 'Update Project Binding' block.

ℹ️ Note: these project variables are not applied dynamically when you run the 'Update Bindings' using the Qlik Automate block. They are appended and only take effect when you import the project.

4. Stop the pipeline currently running in production

For a Change Data Capture (CDC) project, you must stop the project before proceeding with the import.

Use the 'Stop Data Task' block from the 'Qlik Talend Data Integration' connector. You will find the connectors in the Block Library pane on the left side of the automation canvas.

Fill in the ProjectID and TaskID:

ℹ️ We recommend using a logic with variables to handle task stopping in the automation. Please refer to the template configuration and customize it to your needs.

5. Import your project to the PROD space

You’re now ready to import the DEV project contents into the existing PROD project.

⚠️ Warning: Importing the new project will overwrite any existing content in the PROD project.

Using the OneDrive block and the 'Import Project' blocks, we will import the previously saved ZIP file.

ℹ️ In this template, the project ID is handled dynamically using the variable block. Review and customize this built-in logic to match your environment and requirements.
 

After this step is completed, your project is now deployed to production.

6. Prepare your project and check the status

It is necessary to prepare your project before restarting it in production. Preparing ensures it’s ready to be run by creating or recreating the required artifacts (such as tables, etc).

The 'Prepare Project' block uses the ProjectID to prepare the project tasks by using the built-in project logic. You can also specify one or more specific tasks to prepare using the 'Data Task ID' field. In our example, we are reusing the previously set variable to prepare the same PROD project we just imported.

If your pipeline is damaged, and you need to recreate artifacts from scratch, enable the 'Allow recreate' option. Caution: this may result in data loss.

Triggering a 'Prepare' results in a new 'actionID'. This ID is used to query the action status via the 'Get Action Status' API block in Qlik Automate. We use an API polling strategy to check the status at a preset frequency. 

Depending on the number of tables, the preparation can take up to several minutes.

Once we get the confirmation that the preparation action was 'COMPLETED', we can move on with restarting the project tasks.

If the preparation fails, you can define an adequate course of action, such as creating a ServiceNow ticket or sending a message on a Teams channel.

ℹ️ Tip: Review the template's conditional blocks configuration to handle different preparation statuses and customize the logic to fit your needs.

7. Restart the project in PROD

Now that your project is successfully prepared, you can restart it in production.

In this workflow, we use the 'List Data Tasks' to filter on 'landing' and 'storage' for the production project, and restart these tasks automatically.

All done: your production pipeline has been updated, prepared, and restarted automatically!

Now it’s your turn: fetch the Qlik Automate template from the template library and start automating your pipeline deployments.

Related Content

About Qlik Automate

Start a Qlik Talend Cloud® trial

How to get started with the Qlik Talend Data Integration blocks in Qlik Automate

How to use the Qlik Automate templates

A user's last login timestamp can be retrieved using the Qlik Audit API and filtering by the event type: com.qlik.user-session.begin

For more information, see: Audits.

The login timestamps can also be obtained from the Qlik Cloud Entitlement Analyzer app.

Environment

• Qlik Cloud Analytics

By default, the touch screen function cannot be disabled in Qlik Sense Enterprise on Windows. It is enabled whenever the client recognizes a touch-enabled device, such as a mobile phone or tablet. 

It can be disabled manually by the user, but not globally on the server.

To disable Touch Screen mode manually:

1. Click the three dots (ellipsis) in the top left corner
2. Toggle Touch  Screen Mode on or off
   
   

An idea has been created to gather demand on allowing this feature to be disabled on server/administration level. See Option to Disable Touch Screen or toggle Touch Screen off on server side.

Environment:

Qlik Sense Enterprise on Windows 

It is possible to disable touch screen options entirely in, for example, mashups. 

A mashup can send information to the client that sends a fixed device type,  which modifies the UI accordingly.

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

Example:

// Sets device type, which modifies the UI accordingly.
// The device type is automatically detected if it is not manually set.

@function
// String describing the device type.
@param {'auto'|'touch'|'desktop'} deviceType

@example
qlik.setDeviceType('desktop');

 More information could be found on the help site: setDeviceType method

The older API user accounts, which are no longer accessible due to team members departing or their email addresses becoming inactive, are currently unavailable. Consequently, you are unable to manage or update these APIs, as the original owners are absent, and you lack the authority to edit and publish new versions.
For all newly defined APIs, you have the capability to directly assign ownership to the "Architects" group. However, regarding the existing APIs, you are unable to alter their ownership on your own.

Resolution

Talend Cloud API Designer allows you to share APIs with other users and/or groups of users. For additional details, please refer to the sharing api documentation.

Note:  In the Talend Cloud API Designer settings, it is possible to reassign API contracts previously created by deleted users to active connected users. This option is only available for users that have the Administrate API Designer permission enabled.

Environment

• Talend Cloud API Designer & Tester

Deploying an app with Qlik CLI from Git (with app unbuild and app build ) fails when using the --bookmark parameter. 

Resolution

• Verify that the app contains the bookmarks. If the source app has bookmarks, they will be included in the building process. If there are no bookmarks in the source app, they will not appear in the target app. 
• Verify the syntax used:
  
  

  qlik app build --bookmark --app --git-repo

Environment

• Qlik Cloud Analytics
• Qlik CLI

When running extractions in Shopify that involve requesting a large quantity of data, encountered a ServerError.

This is notably seen during initial/historical data extractions.

Cause

Too much data is being requested from Shopify and it creates a Sever Error because Shopify is unable to process the large amount of data via their API.

Resolution

When this error arises, Stitch Subject Matter Experts have the capability to adjust a tuning parameter labeled "Results Per Page". If you encounter this error, it is advisable to consult with a Stitch Subject Matter Expert to establish an appropriate value for this parameter and thereby resolve the issue.

Environment

• Qlik Stitch

A Talend Job includes a tRest component that attempts to post 100kb of JSON/XML data to an API, but fails with the following error: 

tREST component fails with the error "400 , {
"failures": [
{
"field": "name",
"constraint": "Must be a string value, at least 1 character and at most 100 characters long."
},
{
"field": "fields",
"constraint": "Is required."
}
]
}"

Cause

When a Job includes both tRest and tRestClient components, tRest will use CXF implement auto to make HTTP requests. This will cause some random issues, as the CXF framework forces the use of the transfer-encoding header when the body size exceeds 4096. This will result in the post data being chunked (Transfer-Encoding: chunked), and then the server side cannot interpret the data fully as a whole. This was a previously identified defect. 

Resolution

To resolve this issue, a temporary workaround is to select the "Disable chunked encoding" checkbox on tRestClient.

Alternatively, apply the Studio v8-R2025-03 patch.

Internal Investigation ID(s) 

QTDI-1208

Environment

• Talend Data Integration 8.0.1