Browse the Knowledge Hub211 resources
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
At a glance
Tricentis Tosca at a glance
- 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
- Request the trial or a licence, then choose Tosca Cloud in the browser or install Tosca Commander on Windows.
- Create a workspace: single-user for evaluation, multi-user on a shared repository for a team.
- Agree a folder structure and naming convention for Modules, TestCases and test sheets before scanning anything.
- Scan the first screen with XScan, select only the controls you need, and save it as a Module.
- Build a TestCase by dragging Modules in as TestSteps and setting values and ActionModes.
- 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 workspaceA 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 textWhat 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.xmlDistributed 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
| Tool | Authoring | Test languages | Technology reach | Where tests run | Licence |
|---|---|---|---|---|---|
| Tricentis Tosca | Model-based, scriptless Modules and TestCases | None required | Web, SAP, Salesforce, desktop, API, mainframe | Windows agents; Tosca Cloud execution | Commercial, floating licences or SaaS |
| UFT One | Record, keyword view and scripts | VBScript; Python in beta | Web, SAP, Java, .NET, Oracle, mainframe | Windows; Docker for web and API | Commercial, seat or concurrent |
| Selenium | Code against WebDriver bindings | Java, Python, C#, Ruby, JavaScript | Browsers only | Any OS, headless or Grid | Apache 2.0 |
| Playwright | Code with built-in test runner | JS, TS, Python, Java, C# | Chromium, Firefox and WebKit browsers | Any OS, headless by default | Apache 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
UFT One
Commercial Windows functional test automation, now sold as OpenText Functional Testing, with add-ins for web, SAP, Java, .NET, Oracle and terminal emulators.
Selenium
Open-source browser automation built on the W3C WebDriver standard, with official bindings for Java, Python, C#, Ruby and JavaScript.
Resources
Where to go next
Keep going
Prepare, or get it done
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.