⚠️ Queries are available with Business and Enterprise subscriptions.

QQL (Qase Query Language) lets you ask precise questions about your testing data, across projects, time ranges, and entity types, and get back structured results you can export, save, or pin to a dashboard.

If a simple filters answer "show me failed cases," a QQL query answers "show me failed results in the Payments project from the last sprint, grouped by assignee."

Create a new query

You can click on either one of the two buttons to create a new query.

A few example queries:

The fastest way to learn QQL is to read a few real queries. Here's what it looks like in practice.

Failed results from the last two weeks, in one project:

entity = "result"; status = "failed" and project = "PAY" and ended >= now("-14d")

You get every failed result in the PAY project from the last 14 days — case name, run, assignee, and time spent. Perfect for a triage meeting or sprint retro.

Stale test cases, counted by priority:

entity = "case"; SELECT (priority, COUNT(*)) and updated <= now("-90d")  GROUP BY priority

This groups cases nobody has touched in 90 days by priority. If your "High" bucket has 200 untouched cases, that's worth surfacing.

The highest-severity open defects in a project:

entity = "defect"; status = "Open" and project = "PAY" and severity in ["critical", "blocker"]

A one-line shortlist for a release go/no-go decision.

Automation coverage across projects:

entity = "case"; SELECT (project, automation, COUNT(*)) GROUP BY project, automation

This produces a table of automation status per project — handy for reporting progress to engineering leadership.

How QQL works

Every query has two parts:

Entity	what you're searching: a test case, test run, test run result, defect, test plan, or requirement.
Expression	the conditions that filter your results, like status = "Open"` or `created >= now("-7d")

In the Queries screen you pick the entity from a dropdown and write the conditions.

Conditions are joined with and, or, and not, and you can group them with parentheses for anything more involved than a flat list.

Prefer plain English?

You don't have to learn the syntax to get started.

In the Queries screen, describe what you want in natural language:

"failed tests in Payments from last week"

Qase AI turns it into a QQL query you can run, refine, and save. It's the quickest way in; come back to the syntax below when you want precise control.

Where to find it?

Open Queries from the top-left navigation. From there you can:

Run queries against any entity type
Choose which columns appear in your results
Save queries for reuse and pin them to a dashboard as a QQL widget

👉 Read more about Public vs Private queries.

What you can search

Entity	Typical use
Test case	Stale cases, automation gaps, cases by tag or suite
Test run	Active runs, automated runs, runs by milestone
Test run Result	Failure triage, time-spent analysis, assignee workload
Defect	Open defect counts, severity breakdowns, resolution tracking
Test Plan	Plan inventory, per-project counts
Requirements	Coverage tracking, status reviews, type breakdowns

A few patterns worth knowing

Time, without hardcoded dates

Functions like now("-7d"), startOfDay(), and startOfMonth() are relative to when the query runs, so a saved query stays current.

eg: now("-30d") means "the last 30 days," every day.

entity = "case"; author = "jane.doe" and updated <= now("-30d")

Find what's missing

Use is empty / is not empty to find records where a field has no value: like open defects with no milestone:

entity = "defect"; status = "Open" and milestone is empty

Match text loosely

The ~ operator is a case-insensitive contains, so title ~ "login" matches Login, LOGIN, and user-login.

Status, priority, and severity values are matched case-insensitively too, so severity = "blocker" and severity = "Blocker" both work.

Filter on custom fields by title

entity = "case"; cf["Epic"] = "Authentication"

Counting and grouping

Add a SELECT clause to summarize instead of list.

QQL supports COUNT(), MIN(), MAX(), AVG(), SUM(), FIRST(), LAST(), GROUP BY, and HAVING.

Aggregated queries can render as charts in dashboard widgets.

For example, count cases by status but only show statuses with more than 10 cases:

entity = "case"; SELECT (status, COUNT(*)) GROUP BY status HAVING COUNT(*) > 10

Exporting

Query results export to CSV, including the columns currently selected in your view. You can leave the Queries screen while the file is prepared — a notification appears when it's ready.

Quick tips!

Start broad, then narrow: Run a simple query, scan the results, and add conditions. It's easier than debugging a complex query that returns nothing.
Scope to a project early: Adding `project = "CODE"` keeps results focused
Save what you repeat: Save recurring queries and pin them to a dashboard.
Use currentUser() in a saved query (author = currentUser()) so it shows each viewer their own items.

Claude / Agent Skill:

Are you building queries in code, scripts, or with an AI agent?

Queries are also available as a public API endpoint, and via our MCP tool.

The complete, exhaustive reference: every field and operator, plus the public /search API and MCP details is published as the QQL reference for developers here:

👉 GitHub Gist 🔗