View all services
Talk to QA Advisor
Browse the Knowledge Hub211 resources
/Tools Library/Tricentis Tosca
Tools Library · We run this

Tricentis Tosca review: what it is, pricing and setup

Tricentis Tosca is a commercial, codeless test automation platform. Applications are scanned into reusable Modules, and TestCases are built from those Modules with values and actions rather than code, across web, SAP, Salesforce, desktop, API and mainframe. It ships as Tosca Commander, a Windows client whose latest release is 2026.1 LTS, and as Tosca Cloud, a browser-based SaaS updated monthly.

QAble runs this tool on client engagements. The assessment below is from that experience.

last reviewed
13 October 2026
version covered
Tosca 2026.1 LTS and Tosca Cloud (October 2026)
licence
Commercial

Reviewed by Viral Patel

Co-Founder, QAbleLast reviewed 13 October 2026

At a glance

Tricentis Tosca at a glance

Official site
Vendor
Tricentis
Category
Desktop automation, Web automation, API testing
Licence
Commercial
Platforms
Windows, Tosca Cloud (SaaS)
Integrates with
SAP, Jenkins, Jira, qTest, NeoLoad, SeaLights
First released
2007
Version reviewed
Tosca 2026.1 LTS and Tosca Cloud (October 2026)

Verdict

Our verdict on Tricentis Tosca

Strengths

  • Scanned Modules are reused across TestCases, so a changed control is fixed in one place
  • Strong steering for SAP GUI and Fiori, Salesforce, Oracle and other packaged applications
  • Templates plus test sheets generate many data variants from one TestCase design
  • Requirements weighted by damage and frequency classes show risk coverage, not just test counts
  • Tosca Cloud adds browser authoring, cloud agents and agentic test generation from plain language

Weaknesses

  • Commercial and quote-only, with floating licences drawn from a shared pool
  • Assets live in Tosca’s repository, not Git; versioning is check-in and check-out
  • Unattended UI runs on Windows agents need RDP or autologon set up carefully
  • Duplicate Modules and hand-edited template instances erode the maintenance advantage
  • Skills are vendor-specific and transfer poorly to code-based tools

Best for

Large packaged-application estates, SAP above all, plus Salesforce, Oracle and the web and API layers around them, where a business process crosses several systems and the people who know the process are not programmers. Module reuse, test case templates fed by test sheets, and risk weights on requirements are what Tosca does better than code-first tools at that scale, and in our experience its SAP steering is the main reason it gets bought.

Not for

Teams that want tests as code, reviewed in pull requests and versioned in Git: Tosca keeps its assets in its own repository, and nothing about that changes with Tosca Cloud. It is also hard to justify for a straightforward web application, where Playwright or Selenium cover the same ground without licence cost, and for developer-owned testing, where a codeless editor slows engineers down rather than helping them.

Setup cost

High on Tosca Commander: licensing, a shared repository for multi-user workspaces, Tosca Server and agents for distributed execution, and a folder and Module structure that has to be decided before scanning starts. Tosca Cloud removes the server work, with browser authoring and agents installed through Launcher, but the design work is the same. Early Module and template decisions are expensive to reverse, so spend the first weeks on conventions, not coverage.

Maintenance burden

Lower than script-based tools when Module discipline holds, which is Tosca’s whole premise: one Module per screen or control group, reused everywhere, so a UI change is fixed once. It degrades quickly without that discipline. Rescanning a screen instead of finding the existing Module produces duplicates, and editing generated TestCases instead of their Template creates work that the next regeneration discards. Budget for a repository owner who reviews new Modules.

Honest limitations

Version control is Tosca’s own check-in and check-out model on a shared repository, not Git branches and merges, which teams consistently underestimate. Unattended UI execution on Windows agents needs an interactive session, handled through RDP settings on the agents. Pricing is quote-only and licences float from a shared pool. And the codeless promise understates the design skill a maintainable repository needs: Modules, templates, buffers and recovery scenarios are engineering, just without a code editor.

How it works

What is Tricentis Tosca and how does it work?

Modules: the application, scanned once

Tosca separates the technical description of an application from the tests that use it. XScan inspects a screen and saves its controls as a Module, with each control as a ModuleAttribute holding the properties Tosca uses to find it. TestCases never contain locators; they reference ModuleAttributes. A change to a button’s identification is therefore fixed in the Module and every TestCase that uses it follows. Engines, such as TBox for most UI technologies, the API Engine 3.0 and dedicated engines for SAP, Salesforce and PDF, decide how each kind of control is steered. Vision AI scanning, in Tosca Cloud, recognises controls visually where technical properties are missing.

TestCases built from steps, values and ActionModes

A TestCase is a sequence of TestSteps, each pointing at a Module, with a value and an ActionMode per attribute. Input and Insert enter data; Verify checks it; Buffer stores a value for later steps; WaitOn waits for a control to reach a state; Select and Constraint pick a control or a table row by its content. Values can be literal or dynamic expressions: {B[name]} reads a buffer, {CP[name]} a test configuration parameter, {XL[path]} test sheet data in a template, and {CLICK} clicks a control. Reusable TestStep Blocks group common sequences, such as signing in, so they are maintained in one place.

Templates and test sheets generate variants

TestCase-Design separates test data from test logic. A test sheet models the data dimensions of a process, such as customer type, payment method and delivery country, as attributes with instances. A TestCase marked as a template references that data with {XL[...]} expressions, and creating a TemplateInstance generates one concrete TestCase per combination you choose. Regeneration rebuilds the instances from the template, and Tosca marks any generated TestCase that was edited by hand with a ChangedManually property, which is the signal that someone fixed the wrong object. Requirements, weighted by damage and frequency classes, then show which risks the generated cases cover.

Repositories, execution and the cloud

In Tosca Commander, multi-user workspaces sit on a common repository in a shared database. Objects are read-only until checked out, other users cannot change what you hold, and Update all pulls in everyone else’s check-ins. ExecutionLists run TestCases locally, and distributed execution sends them through Tosca Server to agents on Windows machines. Tosca Cloud moves authoring into the browser and execution into playlists, run on personal, team or cloud agents, with a REST API for CI. Licences in both models float: a machine takes one from the pool while a Tosca component runs and returns it when finished.

Strengths

What it does well

Packaged application steering

Tosca’s engines understand SAP GUI and Fiori, Salesforce, Oracle, PowerBuilder, Java and other enterprise technologies at the control level, including tables and trees. Tricentis states coverage of more than 200 technologies. For an SAP-centred landscape this is the capability that matters most: tests address business objects in transactions rather than screen coordinates.

Risk-based coverage

Requirements carry a damage class and a frequency class, each from 0 to 10, and Tosca computes a weight from them. Linking TestCases to requirements turns test results into risk coverage, so a release decision can say that the highest-weighted business processes passed rather than quoting a pass percentage.

Data-driven design at scale

Test sheets, classes and templates generate hundreds of data variants from a handful of designed TestCases, and test configuration parameters switch environments, browsers or credentials without editing steps. That is where Tosca saves the most effort over recorded or scripted suites, provided the template stays the single source of truth.

API and UI in one TestCase

The API Engine 3.0 scans services from definitions and sends messages as TestSteps, and Tosca Cloud can generate API messages from OpenAPI or WSDL specifications. A TestCase can create data through an API, verify it in a SAP screen and check the result in a web portal, with buffers passing values between the layers.

Agentic test generation and Vision AI

Tosca Cloud’s Agentic Test Automation builds TestCases from plain-language descriptions, reusing existing Modules, and from September 2026 can convert manual test cases from integrated systems into automated ones. Vision AI scans controls visually for UIs with poor technical properties. Both work inside the same Module and TestCase model, so their output is reviewable like any other asset.

Integrations across the Tricentis platform

Tosca links requirements and results with qTest and Jira, runs performance scenarios through NeoLoad, and in 2026.1 added parameters for the SeaLights integration that selects tests by code change. Tosca Cloud playlists can be triggered from Jenkins or any CI system through its REST API.

Pricing

Tricentis Tosca pricing and licensing

Tosca is commercial and Tricentis does not publish prices; quotes come from its sales team, typically as subscriptions. Licences float in both delivery models: Tricentis-hosted cloud licensing or your own Tricentis License Server, with each machine drawing a licence from a shared pool while a Tosca component runs. Tosca Cloud is delivered as SaaS with cloud execution agents. A 14-day, cloud-based trial is offered. Infrastructure, agents and trained staff add to the licence cost.

  • Licensing models: cloud licensing hosted by Tricentis, or on-premises licensing through your own Tricentis License Server; both are floating pools.
  • Consumption: each machine running a Tosca component, such as Commander or an execution agent, takes a licence from the pool and returns it when finished.
  • Tosca Cloud: SaaS with automatic updates and elastic cloud execution, which Tricentis positions as paying for the execution capacity a run needs.
  • Trial: a 14-day trial of Tosca, cloud-based and including Agentic Test Automation, requested from tricentis.com.
  • Hidden costs: Windows agents and RDP configuration for unattended runs, a repository owner, and training, since Tosca skills are specific to the product.

Checked against the vendor’s own pages on 13 October 2026. Pricing changes; confirm on the official site before buying.

Getting started

Getting started with Tricentis Tosca

Setup, step by step

  1. Request the trial or a licence, then choose Tosca Cloud in the browser or install Tosca Commander on Windows.
  2. Create a workspace: single-user for evaluation, multi-user on a shared repository for a team.
  3. Agree a folder structure and naming convention for Modules, TestCases and test sheets before scanning anything.
  4. Scan the first screen with XScan, select only the controls you need, and save it as a Module.
  5. Build a TestCase by dragging Modules in as TestSteps and setting values and ActionModes.
  6. Run it from the ScratchBook while designing, then add it to an ExecutionList or a playlist for recorded runs.

Install

Tosca Cloud: sign in to your tenant in a browser, then install Launcher on a Windows machine to run a personal agent
Tosca Commander: run the Tosca installer on Windows, activate a licence (cloud licensing or your Tricentis License Server), and create a workspace

A first example

TestCase: Create standard sales order            (Tosca Commander view)
  TestStep: SAP Logon                               Module: SAP Logon
    Client          Input    {CP[SAPClient]}        test configuration parameter
    User            Input    {CP[SAPUser]}
    Password        Input    {CP[SAPPassword]}
    Log On          Input    {CLICK}
  TestStep: VA01 Initial screen                     Module: VA01 Create Sales Order
    Order Type      Input    OR
    Sales Org.      Input    {CP[SalesOrg]}
    Continue        Input    {CLICK}
  TestStep: VA01 Overview                           Module: VA01 Overview
    Sold-To Party   Input    100045
    Material        Input    M-01
    Order Quantity  Input    5
    Save            Input    {CLICK}
  TestStep: Status bar                              Module: SAP Status bar
    Message         Buffer   OrderNumber            stores the number for later steps
    Message         Verify   Standard Order*        wildcard check of the message text

What trips people up first

Scanning too much, too early. New users scan whole screens, take every control, and create a fresh Module each time they meet a screen they think is new, so within a week there are three Modules for the same SAP transaction and nobody knows which one TestCases use. Before scanning, search the repository for an existing Module, scan only the controls the test needs, and name Modules after the screen or transaction. The second hurdle is identification: if a control is found by a value that changes, such as a generated id, fix its identification properties in the Module, not in each TestCase.

In practice

Using Tricentis Tosca in practice

Repository structure and ownership

Structure the workspace by business process and application, with Modules in a separate area grouped by application and screen, and Reusable TestStep Blocks in a library that TestCases reference rather than copy. Name everything predictably, because search is how people find existing assets. In multi-user workspaces, check out only what you are changing, check in small sets often, and run Update all at the start of each session; long-held check-outs block colleagues and make conflicts more likely. Appoint an owner for the Module area who reviews new Modules for duplicates, and use subset exports, which 2026.1 can restrict by permission, to move assets between workspaces deliberately.

Templates and test sheets for data variants

For any process with several data combinations, design it once as a template. Model the data in a test sheet with attributes for each dimension, mark the TestCase as a template, and replace literal values with {XL[...]} references, using dots for nested attributes. Create a TemplateInstance to generate one TestCase per instance, then add instances rather than copying TestCases. Never fix a generated TestCase by hand: change the template and regenerate. Keep environment-specific values, such as client numbers, URLs and users, in test configuration parameters read with {CP[...]}, so the same TestCases run in test, pre-production and other environments by changing the configuration, not the steps.

Test sheet: Sales orders
  Attributes: Customer.Type, Customer.Number, Payment.Method, Delivery.Country
  Instances:  Domestic-Card, Domestic-Invoice, Export-Invoice, Export-Prepaid

Template TestCase: Create sales order (Template)
  TestStep: VA01 Overview                           Module: VA01 Overview
    Sold-To Party   Input    {XL[Customer.Number]}
    Payment Terms   Input    {XL[Payment.Method]}
    Ship-To Country Input    {XL[Delivery.Country]}
    Save            Input    {CLICK}

TemplateInstance: Create sales order  ->  generates 4 TestCases, one per instance
Environment values stay in configuration: {CP[SAPClient]}, {CP[SalesOrg]}

Running Tosca Cloud playlists from GitHub Actions

Tosca Cloud exposes playlist runs through a REST API, and Tricentis documents the sequence for Jenkins: request an OAuth token with client credentials and the tta scope, start a playlist run, poll its state until it is Succeeded, Failed or Canceled, then download the results as JUnit XML. The same calls work from any CI system. Run on a Tosca Cloud or team agent by setting private to false, keep the client secret in CI secrets, and publish the JUnit file so results appear beside the build. The Tosca CLI, toscactl, offers playlist runs from a terminal too, but on the review date it was limited to the Tricentis Labs programme.

# .github/workflows/tosca-regression.yml
name: tosca-regression
on:
  workflow_dispatch:
jobs:
  playlist:
    runs-on: ubuntu-latest
    env:
      TOSCA_CLOUD_URL: ${{ vars.TOSCA_CLOUD_URL }}   # tenant URL including the workspace
      PLAYLIST_ID: ${{ vars.TOSCA_PLAYLIST_ID }}
    steps:
      - name: Get an access token
        run: |
          TOKEN=$(curl -sf -X POST "${{ vars.TOSCA_AUTH_URL }}" \
            -d "client_id=${{ secrets.TOSCA_CLIENT_ID }}" \
            -d "client_secret=${{ secrets.TOSCA_CLIENT_SECRET }}" \
            -d "scope=tta" -d "grant_type=client_credentials" | jq -r '.access_token')
          echo "::add-mask::$TOKEN"
          echo "TOKEN=$TOKEN" >> "$GITHUB_ENV"
      - name: Start the playlist run
        run: |
          BODY=$(jq -n --arg id "$PLAYLIST_ID" '{playlistId: $id, private: false}')
          RUN_ID=$(curl -sf -X POST "$TOSCA_CLOUD_URL/_playlists/api/v2/playlistRuns/" \
            -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
            -d "$BODY" | jq -r '.executionId // .id')
          echo "RUN_ID=$RUN_ID" >> "$GITHUB_ENV"
      - name: Wait for the result and fetch JUnit XML
        timeout-minutes: 120
        run: |
          while true; do
            STATE=$(curl -sf -H "Authorization: Bearer $TOKEN" "$TOSCA_CLOUD_URL/_playlists/api/v2/playlistRuns/$RUN_ID" | jq -r '.state')
            case "$STATE" in
              Succeeded|Completed) break ;;
              Failed|Canceled|Cancelled) FAILED=1; break ;;
            esac
            sleep 30
          done
          curl -sf -H "Authorization: Bearer $TOKEN" -H "Accept: application/xml" \
            "$TOSCA_CLOUD_URL/_playlists/api/v2/playlistRuns/$RUN_ID/junit" -o junit-results.xml
          [ -z "$FAILED" ]
      - uses: actions/upload-artifact@v7
        if: always()
        with:
          name: tosca-junit
          path: junit-results.xml

Distributed execution and agents

With Tosca Commander, ExecutionLists go to distributed execution: Tosca Server queues the work and agents on Windows machines run it, each taking a licence from the pool. UI tests on those agents need an interactive desktop, so agents run in RDP sessions, and 2026.1 added a key vault timeout for RDP credentials and an option to confirm RDP login messages automatically. In Tosca Cloud the same role is played by personal agents, team agents that can start automatically on Windows, and cloud agents that Tricentis provisions, which since June 2026 can reach private applications through an allowlist rule. In our experience the agent pool, not authoring, sets the pace of a regression cycle, so size it against the licence pool deliberately.

Synchronisation, recovery and keeping runs readable

Most flaky Tosca runs come from timing and unexpected dialogs. Use WaitOn to wait for a control to reach a state before acting, rather than fixed waits, and adjust synchronisation settings for slow systems instead of inserting delays. Define recovery scenarios for pop-ups that may appear and cleanup scenarios that return the application to a known state, so one failure does not cascade through an ExecutionList. Buffer generated values, such as order numbers, and verify them later instead of hard-coding expectations. Keep ExecutionLists aligned to requirements, so a failed run maps directly to the business risk it affects.

Pitfalls

Common pitfalls

Duplicate Modules for the same screen

Why it happens: Scanning feels faster than searching, so each author creates a Module, and TestCases end up spread over several copies that drift apart.

The fix: Search before scanning, give the Module area an owner who reviews additions, name Modules after screens or transactions, and merge duplicates as soon as they are found.

Fixing a generated TestCase instead of its template

Why it happens: The failure appears in the generated TestCase, so people edit it there. Regeneration rebuilds instances from the template, and Tosca flags hand-edited ones as ChangedManually.

The fix: Make every fix in the template or the test sheet and regenerate, and treat any ChangedManually flag as a review item.

Environment values written into TestSteps

Why it happens: Clients, URLs and users typed directly into steps mean a new environment needs edits across hundreds of TestCases.

The fix: Put them in test configuration parameters, reference them with {CP[name]}, and switch environments by changing the configuration.

Fixed waits to handle slow screens

Why it happens: A fixed delay costs time on every run and still fails when the system is slower than the delay.

The fix: Use WaitOn on the control or value that signals readiness, and tune synchronisation settings for the engine rather than adding waits.

Licences held by idle sessions

Why it happens: A machine keeps its licence while a Tosca component runs, so an open but unused Commander or an idle agent can starve the pool.

The fix: Close Commander when not in use, enable idle licence return where your version offers it, and size agents against the licence pool.

Unattended agents that fail when nobody is watching

Why it happens: UI steering needs an interactive desktop, so agents whose RDP session is closed or locked cannot drive the application.

The fix: Configure agents for RDP or loopback RDP sessions as the documentation describes, store RDP credentials in the supported key vault, and test unattended runs before relying on them.

Compared

How Tricentis Tosca compares

ToolAuthoringTest languagesTechnology reachWhere tests runLicence
Tricentis ToscaModel-based, scriptless Modules and TestCasesNone requiredWeb, SAP, Salesforce, desktop, API, mainframeWindows agents; Tosca Cloud executionCommercial, floating licences or SaaS
UFT OneRecord, keyword view and scriptsVBScript; Python in betaWeb, SAP, Java, .NET, Oracle, mainframeWindows; Docker for web and APICommercial, seat or concurrent
SeleniumCode against WebDriver bindingsJava, Python, C#, Ruby, JavaScriptBrowsers onlyAny OS, headless or GridApache 2.0
PlaywrightCode with built-in test runnerJS, TS, Python, Java, C#Chromium, Firefox and WebKit browsersAny OS, headless by defaultApache 2.0

FAQ

Frequently asked questions

Is Tricentis Tosca free?

No. Tosca is commercial and Tricentis does not publish prices; you get a quote from its sales team. Licences float, from Tricentis-hosted cloud licensing or your own Tricentis License Server, and each machine running a Tosca component draws one from the pool. A 14-day cloud-based trial, including Agentic Test Automation, can be requested from the Tricentis website.

What is the difference between Tosca Commander and Tosca Cloud?

Tosca Commander is the Windows desktop client, released as versions such as 2026.1 LTS, with workspaces on a shared repository and distributed execution through Tosca Server. Tosca Cloud is the SaaS edition: authoring in the browser, monthly releases, playlists run on personal, team or cloud agents, and features such as Agentic Test Automation. Tricentis supports uploading folders from Commander to Cloud for teams that are moving.

Should I choose Tosca or UFT One?

Both target enterprise estates with SAP and other packaged applications. Choose Tosca when non-programmers will build tests, when data variants and risk-weighted requirements matter, or when you want a SaaS option. Choose UFT One when your team prefers scripting, already relies on OpenText ALM, or needs its particular add-ins, such as terminal emulators or PowerBuilder, for the technologies in scope.

Do you need to know how to code to use Tosca?

Not to build TestCases: Modules, TestSteps, values and ActionModes replace code, and business analysts can contribute. A maintainable repository still needs engineering judgement, in Module design, templates, buffers, recovery scenarios and execution setup, and API tests need an understanding of the services. Expect a small group of experienced Tosca engineers to own the structure while others author within it.

Can Tosca tests be stored in Git?

Not as a working repository. Tosca Commander keeps assets in its own repository, with check-in and check-out for multi-user workspaces, and Tosca Cloud keeps them in cloud workspaces. Subsets can be exported and imported to move assets between workspaces, but branching and merging in Git is not how Tosca teams collaborate, so plan reviews around Tosca’s own model.

How do I run Tosca tests from a CI pipeline?

For Tosca Cloud, call its REST API: get a token with client credentials, start a playlist run, poll its state and download JUnit XML, as Tricentis documents for Jenkins. The same calls work from GitHub Actions or Azure DevOps. For Tosca Commander, CI triggers distributed execution through Tosca Server, with Windows agents running the tests in interactive sessions.

Is Tosca worth learning in 2026?

Yes if you work in, or want to join, organisations with SAP or other packaged-application estates, where Tosca is widely used and experienced engineers are in demand. Its concepts, model-based design and risk-based coverage, are useful anywhere. For a broad automation career, pair it with a code-based tool such as Playwright or Selenium, since Tosca skills transfer poorly on their own.

Alternatives

Tricentis Tosca alternatives worth weighing

Resources

Where to go next

Keep going

Prepare, or get it done

Ready

Picking the wrong tool costs more than picking late.

QAble advises on toolchain decisions and then implements them, with engineers who have run these tools on real delivery. Start with a free QA audit.

Talk to QA Advisor