View all services
Talk to QA Advisor
Browse the Knowledge Hub211 resources
Tools Library · Review and guide

Xray review: pricing, alternatives and setup

Xray is a test management app for Jira that models tests, preconditions, test sets, test plans and test executions as Jira work types, so tests sit beside the stories and bugs they relate to. It imports results from JUnit, TestNG, NUnit, Robot Framework, Cucumber and Behave, and reports coverage per requirement. It is sold on the Atlassian Marketplace by Xblend, part of Idera’s Sembi group.

QAble has evaluated this tool and works alongside it. The factual sections are complete; our view is bounded to what we have actually seen rather than a long-term verdict.

last reviewed
13 October 2026
version covered
Xray Cloud 16 (Standard and Advanced editions)
licence
Commercial

Reviewed by Viral Patel

Co-Founder, QAbleLast reviewed 13 October 2026

At a glance

Xray at a glance

Official site
Vendor
Xblend / Sembi
Category
Test management
Licence
Commercial
Platforms
Jira Cloud, Jira Data Center
Integrates with
Jira, Jenkins, Cucumber, Behave, JUnit XML, TestNG, NUnit, Robot Framework, GraphQL API
First released
2013
Version reviewed
Xray Cloud 16 (Standard and Advanced editions)

Verdict

Our verdict on Xray

Strengths

  • Tests, plans and executions are Jira work items, so JQL, links, permissions and dashboards apply directly
  • Requirement coverage reports show each story’s test status per version, test plan or environment
  • Imports JUnit, TestNG, NUnit, xUnit, Robot Framework, Cucumber and Behave results through REST
  • Cucumber scenarios can be authored in Jira and exported as feature files, or imported from the repository
  • REST and GraphQL APIs plus an official Jenkins plugin for CI integration

Weaknesses

  • Priced on every Jira user on the site, so cost scales with the whole Jira estate, not the test team
  • Every test, set, plan and execution is a work item, which adds volume to spaces and searches
  • Cloud data is stored on Xray’s own infrastructure, outside Jira, which matters for data reviews
  • Advanced features such as versioning and dynamic plans need the separate Xray Enterprise app

Our take

Xray fits teams whose quality evidence has to live in Jira: requirement to test to execution to defect, queryable with JQL and reportable per release, which is often what regulated or audited projects need. Because tests are Jira work items, Jira’s permissions, links and filters apply to them with no synchronisation layer. QAble has evaluated Xray rather than maintained a long-running test estate in it, so treat this as a bounded take. Watch three things. Licences cover every Jira user on the site, not just testers. Tests and executions add many work items to Jira, so plan spaces and filters before importing years of history. And Xray Cloud is mid-way through its move to Atlassian Forge, with Atlassian ending support for Connect apps in December 2026, so check release notes for behaviour changes during that period.

We have evaluated this tool rather than maintained a long-running suite on it, so this is a bounded view rather than a long-term verdict. The rest of this page is factual.

How it works

How Xray works

Tests modelled as Jira work types

Installing Xray adds work types: Test, Precondition, Test Set, Test Plan, Test Execution and Sub-Test Execution. A Test is a work item with a test type, by default Manual for step-based tests, Cucumber for Gherkin scenarios, Generic for unstructured automated tests, or Exploratory. Test Sets group tests, Test Plans hold the tests intended for a release or milestone, and Test Executions record a run of some of those tests against a version and environment. Because all of these are work items, the usual Jira machinery applies: links to stories and bugs, JQL, permissions, notifications and boards. That is the core design choice, and both the strengths and the overheads follow from it.

Test runs and coverage status

Each test inside a Test Execution becomes a test run with its own status, step results, evidence, comments and defects. Xray aggregates the latest relevant runs into coverage: for each story or other coverable work item, the Test Coverage report shows whether its tests are OK, NOK, NOT RUN, UNKNOWN or UNCOVERED, for a chosen version, test plan or test environment. Test environments let the same test pass on one browser or platform and fail on another without overwriting results. This is what turns individual executions into an answer to the release question: which requirements are covered and passing for this version.

Data stored outside Jira on Cloud

Atlassian does not hold third-party app data, so on Jira Cloud Xray stores its entities, such as steps, runs and evidence, on Xray’s own servers, by default in North Carolina in the United States, with data residency options for the European Union, Germany and Australia. On Data Center, Xray data sits in the Jira database. Xray Cloud is migrating to Atlassian Forge as a Forge Remote app that still runs on Xray’s servers, with a first phase released in July 2026 and a second targeted for autumn 2026. For security reviews, treat Xray Cloud as a separate data processor from Atlassian.

Automation results arrive through import

Xray does not run tests. Your framework runs them in CI and produces a report, such as JUnit XML or Cucumber JSON, which you post to Xray’s REST API. Xray creates or updates a Test Execution, matches each result to an existing Test or creates one, and records a run. For JUnit-style reports, unmatched results become new tests keyed by class and method name, so renaming a test method creates a new Test unless the result carries an explicit key. For Cucumber, scenarios tagged with a test key update that Test. Authentication on Cloud uses a client ID and secret exchanged for a bearer token.

Strengths

What it does well

Traceability as a query

Because tests and executions are work items linked to stories and bugs, traceability questions become JQL and link navigation rather than reports assembled by hand. Which stories in this release have no tests, and which failed tests have open bugs, can be answered in Jira itself and shown on dashboards that the rest of the organisation already uses.

Coverage per version and environment

The Test Coverage report computes status per requirement for a version, test plan or environment, using the latest relevant runs. Release reviews get a single view of covered and uncovered requirements, and environment-specific results stop a pass on Chrome hiding a failure on Safari.

Broad automation import

REST endpoints accept Xray JSON, Cucumber JSON, Behave JSON, JUnit XML, TestNG XML, NUnit XML, xUnit XML and Robot Framework output, each with a multipart variant for setting Test Execution fields. Almost any framework that writes JUnit XML can therefore report into Xray without a dedicated plugin.

Cucumber in both directions

Scenarios can be written as Cucumber Tests in Jira and exported as feature files tagged with their test keys, or written in the repository and imported into Xray. Results from Cucumber JSON update the matching Tests. Teams can choose whether Jira or Git is the source of truth for scenarios, which few test management tools support.

APIs and CI plugins

Xray Cloud offers REST v2 and a GraphQL API with the same authentication, plus regional endpoints for data residency. The official Jenkins plugin, Xray Test Management for Jira, imports results and exports Cucumber features for both Cloud and Data Center. API calls are rate limited per Jira instance, with higher limits on Advanced and Enterprise.

AI-assisted test design

Recent Cloud releases add opt-in AI features: test case generation from requirements, AI test prioritisation with limits per edition, and a Rovo test plan summariser, with AI test model and script generation reserved for higher editions. Xray states that customer data is not used for model training. Review generated tests as drafts.

Pricing

Xray pricing and licensing

Xray is a commercial Jira app sold through the Atlassian Marketplace and paid via Atlassian. Its user tier must match the Jira site’s user tier, so you license every Jira user, not only testers. Xray Cloud comes in Standard and Advanced editions; Xray Enterprise is a separate app for Cloud and Data Center. A 30-day trial is available. No list prices are quoted here: Xray’s calculator shows estimates and points to the Marketplace for quotes.

  • Licence model: per Jira user tier on the Marketplace, matching the tier and billing cycle of the Jira site; a 100-user Jira needs a 100-user Xray.
  • Standard: the core test management features, API limit of 60 requests per minute and 100 GB of storage on Cloud.
  • Advanced: Standard plus smarter test design, usage insights, more AI capacity, 250 GB of storage and 100 API requests per minute.
  • Xray Enterprise: a separate app adding test case versioning, dynamic JQL-based test plans, Test Case Designer, remote job triggers, unlimited storage and 200 API requests per minute.
  • Trial: 30 days, extendable through Xray’s customer advocates.
  • Hidden costs: licences sized to all Jira users, work item volume in Jira, and CI scripting to keep results flowing in automatically.

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 Xray

Setup, step by step

  1. Install Xray from the Atlassian Marketplace on your Jira site and start the 30-day trial.
  2. Add the Xray work types to a space, following the Quick Setup guide in the Xray documentation.
  3. Create a Test for an existing story and link it with the tests relationship.
  4. Create an API key in Xray’s global settings to get a client ID and client secret.
  5. Run your automated tests in CI with a JUnit XML or Cucumber JSON report.
  6. Authenticate against the REST API and import the report into a Test Execution.

Install

# Xray is a Jira app: install it from the Atlassian Marketplace
# https://marketplace.atlassian.com/apps/1211769/xray-test-management-for-jira
# Then create an API key (client ID and secret) in Xray global settings

A first example

# Import JUnit XML results into Xray Cloud (REST v2)
# Use the regional host (us., eu., au.) that matches your data residency
XRAY=https://xray.cloud.getxray.app

# 1. Exchange the API key for a bearer token.
#    The response is a JSON string in quotes, so strip them.
TOKEN=$(curl -s -H "Content-Type: application/json" -X POST \
  --data "{\"client_id\":\"$XRAY_CLIENT_ID\",\"client_secret\":\"$XRAY_CLIENT_SECRET\"}" \
  "$XRAY/api/v2/authenticate" | tr -d '"')

# 2. Import results: creates a Test Execution in space SHOP,
#    links it to Test Plan SHOP-12 and records the revision.
#    Any JUnit XML file works; this is xray-junit-extensions’ default path.
curl -s -H "Content-Type: text/xml" -H "Authorization: Bearer $TOKEN" \
  --data @target/TEST-junit-jupiter.xml \
  "$XRAY/api/v2/import/execution/junit?projectKey=SHOP&testPlanKey=SHOP-12&revision=$GIT_SHA"

What trips people up first

Duplicate Tests after every pipeline run. Xray matches JUnit-style results to existing Tests by name, and creates a new Generic Test for anything it does not recognise, so renaming a test method or a parameterised display name quietly produces new Tests and orphans the old history. Decide early how automated results map to Tests: let Xray auto-provision them and keep names stable, or put explicit keys in the report, for example with the xray-junit-extensions library and @XrayTest(key = "SHOP-123") in JUnit 5 and 6. For Cucumber, keep the test key tags on scenarios. The other early trap is pointing at the global API host when the site uses a regional data residency host.

In practice

Using Xray in practice

Modelling plans, executions and environments

Decide the model before importing anything. A common structure is one Test Plan per release, holding every test that should pass for that release, with Test Executions for each run: one per CI pipeline run for automated suites and one per manual cycle. Use test environments, such as chrome, firefox or staging, instead of separate plans for each environment, so coverage can be read per environment for the same version. Group reusable groups of tests in Test Sets, and use Preconditions for shared setup that several manual tests depend on. Keep Xray’s work items in the same space as the stories they cover where possible, because coverage and linking are simplest within a space, and agree naming rules for executions so filters can find them.

Linking automated JUnit tests to existing Tests

To keep history on the right Test, carry the Test key in the report rather than relying on names. Xray publishes xray-junit-extensions for JUnit 5 and 6: register its EnhancedLegacyXmlReportGeneratingListener, then annotate test methods with @XrayTest(key = ...) to link to an existing Test, or @XrayTest(summary = ...) to auto-provision one with a readable summary, and @Requirement to link the covered story. The listener writes an enhanced JUnit XML report, by default target/TEST-junit-jupiter.xml, that the junit import endpoint understands. Tests without a key are still auto-provisioned from class and method names.

// pom.xml: app.getxray:xray-junit-extensions:1.0.1 (test scope)
// Register the listener in
// src/test/resources/META-INF/services/org.junit.platform.launcher.TestExecutionListener:
//   app.getxray.xray.junit.customjunitxml.EnhancedLegacyXmlReportGeneratingListener

import app.getxray.xray.junit.customjunitxml.annotations.Requirement;
import app.getxray.xray.junit.customjunitxml.annotations.XrayTest;
import org.junit.jupiter.api.Test;

class CheckoutTest {

  @Test
  @XrayTest(key = "SHOP-123")   // results update this existing Test
  @Requirement("SHOP-45")       // links the Test to the story it covers
  void goldMembersGetTenPercentOff() {
    // ...
  }

  @Test
  @XrayTest(summary = "Guest checkout with a saved basket")
  void guestCheckout() {
    // auto-provisioned on first import, with this summary
  }
}

Importing results from GitHub Actions

Xray does not publish an official GitHub Action, so the dependable route is a step that authenticates and posts the report with curl, as the REST documentation shows. Store the client ID and secret as repository secrets, run the import even when tests fail, since failures are the results that matter most, and pass the test plan key and revision so each execution is attributable to a release and commit. Use the regional host if your site uses data residency. Keep an eye on API limits per Jira instance if many pipelines import at once.

# .github/workflows/tests.yml (excerpt)
      - name: Run tests
        run: mvn -B verify
      - name: Import results into Xray
        if: always()
        env:
          XRAY: https://xray.cloud.getxray.app
          XRAY_CLIENT_ID: ${{ secrets.XRAY_CLIENT_ID }}
          XRAY_CLIENT_SECRET: ${{ secrets.XRAY_CLIENT_SECRET }}
        run: |
          TOKEN=$(curl -sf -H "Content-Type: application/json" -X POST \
            --data "{\"client_id\":\"$XRAY_CLIENT_ID\",\"client_secret\":\"$XRAY_CLIENT_SECRET\"}" \
            "$XRAY/api/v2/authenticate" | tr -d '"')
          curl -sf -H "Content-Type: text/xml" -H "Authorization: Bearer $TOKEN" \
            --data @target/TEST-junit-jupiter.xml \
            "$XRAY/api/v2/import/execution/junit?projectKey=SHOP&testPlanKey=SHOP-12&revision=${{ github.sha }}"

Running Cucumber with Xray as the source of scenarios

When product owners write scenarios in Jira, the loop is export, run, import. Export feature files for a set of Test keys or a saved filter with the export/cucumber endpoint, which returns a zip; unzip it into the features folder, run Cucumber with the JSON plugin, and post the JSON to the Cucumber import endpoint. Exported scenarios carry their Test keys as tags, optionally with a prefix such as TEST_ set in Xray’s global Cucumber settings, and that is how results find their Tests. Two cautions: do not edit exported features in Git, since the next export overwrites them, and on Cucumber-JVM 8 add Jackson as a dependency, because the json plugin no longer bundles it.

# Export scenarios for Tests SHOP-6 and SHOP-7 (keys separated by ;)
curl -s -H "Authorization: Bearer $TOKEN" \
  "$XRAY/api/v2/export/cucumber?keys=SHOP-6;SHOP-7" -o features.zip
rm -rf src/test/resources/features && mkdir -p src/test/resources/features
unzip -o features.zip -d src/test/resources/features

# Run Cucumber with the json plugin, then import the results
mvn -B verify -Dcucumber.plugin=json:target/cucumber.json || true
curl -s -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
  --data @target/cucumber.json \
  "$XRAY/api/v2/import/execution/cucumber"

Keeping an Xray instance usable over time

Volume is the long-term problem. A pipeline that imports on every push creates a Test Execution each time, and after a year those work items dominate searches and boards. Import full executions on main and nightly builds, not on every branch push, and archive or move old executions according to a retention rule. Agree which statuses and environments exist and keep them few. Review coverage per release with product owners, since an uncovered requirement is a planning conversation, not a test artefact. If you need versioned test cases or JQL-driven dynamic test plans, those are in Xray Enterprise, a separate app, so evaluate it before building workarounds.

Pitfalls

Common pitfalls

New Tests created on every renamed method

Why it happens: JUnit-style imports match results to Tests by name and auto-provision anything unmatched, so a rename or a changed parameterised display name creates a new Test and splits the history.

The fix: Carry explicit keys in the report with xray-junit-extensions and @XrayTest(key), or keep names stable by convention, and periodically search for Generic Tests with no recent runs.

Underestimating licence cost

Why it happens: Marketplace apps must match the Jira site’s user tier, so a 500-user Jira site needs a 500-user Xray licence even if ten people test.

The fix: Price Xray against the full Jira user tier before choosing it, and compare with a standalone tool licensed per tester if most Jira users never touch tests.

Tokens and imports failing against the wrong host

Why it happens: Sites using Xray data residency must use the regional API host, such as eu.xray.cloud.getxray.app, and tutorials usually show the global host.

The fix: Use the host that matches your Xray region for authentication, REST and GraphQL calls, and keep it in one CI variable.

Editing exported Cucumber features in Git

Why it happens: When Jira is the source of truth, each export overwrites the feature files, so scenario edits made in the repository are lost on the next run.

The fix: Pick one source of truth. Edit scenarios in Jira and export, or keep features in Git and import them with the import/feature endpoint.

Execution volume swamping Jira

Why it happens: Each import creates a Test Execution work item. Pipelines that import on every branch push generate thousands of executions that slow searches and clutter boards.

The fix: Import on main, nightly and release pipelines, reuse a Test Execution key for reruns where appropriate, and set a retention practice for old executions.

Hitting API rate limits in busy CI

Why it happens: Xray Cloud limits API calls per Jira instance, at 60 requests per minute on Standard according to its knowledge base, so many parallel pipelines importing at once can be throttled.

The fix: Import one combined report per run rather than per shard, retry with back-off, and consider Advanced or Enterprise if imports are a core workflow.

Compared

Xray alternatives compared

ToolWhere tests liveHostingWho must be licensedJQL on tests
XrayAs Jira work itemsJira Cloud and Data Center appEvery Jira user on the siteYes, tests are work items
ZephyrOwn test library, linked to JiraJira Cloud and Data Center appEvery Jira user on the siteNo, test cases are not work items
TestRailStandalone tool with a Jira integrationCloud, or on-premise on higher plansEach TestRail userNo, separate tool

FAQ

Frequently asked questions

What are the best Xray alternatives?

The alternatives most often weighed against Xray are Zephyr, TestRail and Qase. The comparison on this page sets them side by side on where tests live, hosting, who must be licensed and jql on tests, and the verdict above says where Xray is the wrong choice and which of them to pick instead.

How much does Xray cost?

Xray is sold on the Atlassian Marketplace and priced by user tier, and the tier must match your Jira site’s user count, so you license every Jira user. Cloud has Standard and Advanced editions, and Xray Enterprise is a separate app. Xray’s own calculator shows only estimates and directs buyers to the Marketplace for a quote, so check the Marketplace pricing tab for your user tier. A 30-day trial is available.

Xray vs Zephyr: which should I choose?

The main difference is storage. Xray makes tests, plans and executions Jira work items, so JQL, links and Jira permissions apply directly, at the cost of more work items in your spaces. Zephyr keeps test cases, cycles and plans in its own library linked to Jira, which keeps spaces cleaner and suits test-specific features such as versioning and folders. Both are priced per Jira user tier on the Marketplace.

Can Xray import Playwright, Cypress or pytest results?

Yes, through JUnit XML, which all three can produce: Playwright and Cypress with their JUnit reporters, and pytest with --junitxml. Post the file to the junit import endpoint and Xray creates or updates a Test Execution. Results map to Tests by name unless the report carries Test keys, so keep test names stable or use Xray JSON when you need full control over mapping and evidence.

Where does Xray Cloud store data?

Outside Jira. Atlassian does not host third-party app data, so Xray Cloud stores its entities on Xray’s own infrastructure, by default in North Carolina in the United States. Data residency options exist for the European Union, Germany and Australia, pinned through Atlassian’s data residency settings. On Data Center, Xray data lives in the Jira database. Include Xray in vendor and data protection reviews.

What is the difference between Xray Standard, Advanced and Enterprise?

Standard and Advanced are editions of the Xray Cloud app introduced in October 2025; Advanced adds smarter test design, usage insights, more AI capacity, 250 GB instead of 100 GB of storage and a higher API limit. Xray Enterprise became a separate app in October 2025, for Cloud and Data Center, adding test case versioning, dynamic test plans, Test Case Designer, remote job triggers and unlimited storage.

Does Xray support Cucumber?

Yes. Cucumber is a built-in test type. You can write scenarios in Jira and export them as feature files tagged with their Test keys, or keep features in your repository and import them. After a run, posting the Cucumber JSON report updates the matching Tests and creates a Test Execution. On Cucumber-JVM 8, the json plugin needs Jackson declared as a dependency.

Is Xray affected by Atlassian’s Data Center end of life?

Xray continues to list Data Center compatibility, and Xray Enterprise is available for Data Center. But Atlassian stopped selling new Data Center subscriptions on 30 March 2026 and ends Data Center on 28 March 2029, so Xray Data Center has the same horizon as Jira Data Center. Xray’s own Forge documentation notes Server and Data Center are a separate product not moving to Forge.

Alternatives

Xray alternatives worth weighing

Resources

Where to go next

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