Jira IssueFunction: A Practical Guide to JQL Extensions
Need to find linked Jira issues? Learn how issuefunction jira extends JQL for relationship searches. Read now to simplify your queries.
Jira Query Language works well for finding issues by fields such as project, status, and assignee. It gets harder when you need to search across relationships, like finding every issue linked to a particular task.
That gap can turn a simple report into a maze of saved filters, manual checks, and queries that miss related work. You may also see examples using unfamiliar syntax and wonder whether Jira supports it natively.
IssueFunction extends JQL with functions for searching related Jira issues. In this guide, you’ll learn what the `issueFunction` field does, how to write common queries, and what to check when results look wrong. But here’s the truth: the function name is only one part of a dependable query. You also need to understand the app that provides it, the relationship you’re searching, and your Jira deployment’s compatibility.
What IssueFunction Means in Jira
Jira IssueFunction is a ScriptRunner JQL extension that lets you search for issues through relationships and other conditions that standard JQL may not cover directly. It uses the `issueFunction` field with a function name and, often, a JQL subquery.
For example, a standard query can find issues in a project or with a particular status. An IssueFunction query can find issues linked to results of another query, or subtasks belonging to matching parent issues.
IssueFunction is provided by the ScriptRunner app for Jira; it is not a built-in Jira field. The app needs to be available and configured for your Jira environment before these functions can run.

How the query is structured
A common pattern looks like this:
issueFunction in functionName("JQL subquery")
The outer JQL selects the function, while the quoted subquery identifies a set of issues for that function to examine. You can often combine the function with regular JQL clauses, such as a project or status condition.
For instance, this query searches for issues linked to issues in the PAY project:
issueFunction in linkedIssuesOf("project = PAY")
Let me explain: the function does not replace JQL. It adds ways to express relationships that would otherwise be difficult or unavailable in a single query.
Useful IssueFunction Queries and Examples
The right function depends on the relationship you want to follow. Here are several common patterns; confirm the function’s availability and syntax in your ScriptRunner version.
| Goal | Example JQL | What it finds |
| Find issues linked to a matching issue | issueFunction in linkedIssuesOf("project = PAY") | Issues connected to issues in the PAY project |
| Find issues linked through a specific link type | issueFunction in linkedIssuesOf("key = PAY-42", "blocks") | Issues connected to PAY-42 through the named relationship |
| Find subtasks of matching parents | issueFunction in subtasksOf("project = PAY AND status = Open") | Subtasks belonging to open PAY issues |
| Find parent issues of matching subtasks | issueFunction in parentsOf("project = PAY AND status = Blocked") | Parents of blocked PAY issues |
| Find issues within matching epics | issueFunction in issuesInEpics("project = PAY AND status = Open") | Issues whose epics match the subquery |
Consider a release team tracking blockers. A query using `linkedIssuesOf` can help locate issues connected to a known blocker, while `subtasksOf` can reveal unfinished child work beneath open parent issues.
Function names and accepted arguments can vary by ScriptRunner edition and Jira deployment. Treat these examples as patterns, then check the installed version’s documentation before relying on a query in a dashboard or recurring report.
Choose the function by relationship
- Use `linkedIssuesOf` when you need to follow Jira issue links.
- Use `subtasksOf` to find child issues under parent issues that match a subquery.
- Use `parentsOf` to move from matching issues to their parent issues.
- Use `issuesInEpics` when the subquery identifies epics whose issues you want to find.
- Use `epicsOf` when you need epics associated with issues returned by a subquery.
The function’s direction matters. For example, searching for issues in selected epics is different from searching for the epics associated with selected issues.
How to Write and Validate a Query
Start with the relationship you need, then build and test the query in small pieces. A short, verified query is easier to troubleshoot than a complex filter with several nested conditions.
- Describe the result you need. Write down whether you want linked issues, parents, subtasks, epic members, or another relationship.
- Test the subquery on its own. Run a normal JQL query such as
project = PAY AND status = Open and check that it returns the expected starting issues.
- Add the IssueFunction wrapper. Replace the sample function and subquery with the relationship and issue set you identified.
- Add regular JQL filters. Narrow the result with fields such as project, assignee, or status, if needed.
- Compare a few results manually. Open representative issues and confirm their links, parent relationships, or epic membership.
- Save and name the filter clearly. A name like “Open subtasks under PAY parents” tells teammates what the query is meant to return.
Here’s why: a function can be syntactically correct and still return unexpected issues if its subquery selects the wrong starting set. Testing that subquery first isolates the problem.
For example, begin with project = PAY AND status = Open. Once that returns the intended parent issues, use it inside `subtasksOf` to find their subtasks.
Check quoting and link names
Keep the subquery inside quotation marks as shown in the function’s supported syntax. If a value includes spaces, use the quoting rules that apply to that JQL field.
When filtering by a link type, use the relationship name recognized by your Jira configuration and ScriptRunner version. If the query returns no results, test the issue link itself before changing several parts of the JQL at once.
When IssueFunction Helps—and What to Check
IssueFunction is most useful when a report depends on relationships between issues. A release manager might need blockers connected to a release ticket, while a team lead may want open subtasks beneath unresolved parent work.
It can also reduce manual review. Instead of opening each epic to inspect its issues, a team can use an appropriate function to build a filter for a dashboard or recurring review.
The best part? You can keep familiar JQL conditions alongside the extension. A team could search for linked issues and then narrow results by project, status, or another supported field.
Check compatibility before sharing filters
Confirm that ScriptRunner is installed for the Jira product and deployment your team uses. Jira Cloud and self-managed Jira environments can differ in supported functions, syntax, and behavior.
Also check access. Teammates may need suitable Jira permissions and access to the app for a saved filter or dashboard to work as expected. If someone sees an error while another teammate gets results, compare app access and permissions first.
Keep queries manageable
Large subqueries and broad relationships can make a filter harder to understand and may take longer to evaluate. Begin with a narrow project or issue key, verify the results, then expand the scope only when needed.
For example, test a link query against one known issue before searching across several projects. If the smaller query behaves as expected, widen its scope and check the results again.
ONES.com is a unified platform for project management and knowledge management, with ONES Project for project management and ONES Wiki for knowledge management. The products are sold separately, so you can choose the capability that fits your team.

If your team is reviewing Jira alternatives because complex workflows depend on multiple add-ons, compare how much of your daily work the platform can handle natively. ONES Project supports Jira-compatible workflows, reporting, custom workflows and fields, sprint management, and automation. It is a Jira alternative for teams that want project management capabilities alongside self-hosted deployment options.
Core capabilities
- Pain: Teams rely on separate systems for project work and internal knowledge. ONES capability: ONES.com brings project management and knowledge management into one platform through ONES Project and ONES Wiki. Result: Teams can choose connected capabilities while purchasing the products separately.
- Pain: A team wants familiar Jira-style processes when evaluating another platform. ONES capability: ONES Project supports Jira-compatible workflows. Result: Teams can assess a Jira alternative without discarding every established workflow.
- Pain: A fixed workflow does not reflect how a team handles work. ONES capability: Custom workflows and fields let teams shape processes and issue details. Result: Work tracking can better reflect the team’s operating needs.
- Pain: Sprint planning and progress tracking require extra coordination. ONES capability: ONES Project includes sprint management and built-in reporting. Result: Teams can plan iterations and review progress within their project management environment.
- Pain: Repetitive task handling adds avoidable manual steps. ONES capability: Automation supports routine project workflows. Result: Teams can reduce repeated actions in processes they configure.
- Pain: Plugin dependence can add operational complexity. ONES capability: ONES Project provides core project management features natively. Result: Teams can evaluate whether fewer add-ons meet their needs.
- Pain: An organization needs control over where its environment runs. ONES capability: Deployment options include Cloud, On-Premise, Private Cloud, and Air-gapped environments. Result: The organization can assess an option that fits its hosting requirements.
- Pain: Teams worry that self-hosting may mean losing features. ONES capability: Cloud and self-hosted versions have full feature parity. Result: Deployment choice does not require choosing between the stated feature sets.
Application scenarios
A software team with sprint planning, custom issue fields, and recurring reports could assess ONES Project as a Jira alternative. It can map its existing workflow needs to the platform’s native capabilities before deciding which processes to change.
An organization with strict hosting requirements could compare On-Premise, Private Cloud, or Air-gapped deployment with Cloud. A team that also wants a knowledge base can evaluate ONES Wiki separately from ONES Project.
ONES.com offers a free plan for up to 30 seats. Teams can use that limit to assess whether the available project and knowledge management capabilities fit their practical needs.
Common Challenges and Practical Fixes
- The function is unrecognized. Check whether ScriptRunner is installed and available for your Jira environment. Then verify that the function is supported by your app edition and version.
- The query returns no issues. Run the quoted subquery by itself, then inspect the relationship on a known issue. Confirm that the link type, parent-child relationship, or epic association matches your intended search.
- The query returns too many issues. Narrow the subquery with a project, status, issue key, or other relevant JQL condition. Expand the scope only after checking a smaller result set.
- A teammate cannot use a saved filter. Confirm Jira permissions, filter sharing settings, and access to ScriptRunner. The filter’s owner may have access that other viewers do not.
- A query behaves differently after a change. Check the Jira deployment and ScriptRunner version, then compare the function syntax with the documentation for that environment. Avoid assuming that Cloud and self-managed installations behave identically.
Frequently Asked Questions
Is `issueFunction` part of Jira’s standard JQL?
No. `issueFunction` is provided by ScriptRunner for Jira, rather than being a standard Jira field. The app must be available in your Jira environment for its JQL functions to work. If Jira reports that the field or function is unknown, check the installation, app access, and compatibility with your deployment.
Can I use IssueFunction in a saved filter?
Yes, when the function is supported in your environment and you have the required access. You can save a working query and use it where Jira permits that filter, such as a dashboard gadget. Check sharing permissions and app access so teammates can view or run it as intended.
Why does my IssueFunction query return no results?
First, run the subquery on its own and confirm that it returns the issues you expect. Next, inspect the relationship you want to follow, such as the issue link type or parent-child connection. Check spelling, quotation marks, function arguments, and whether the function is supported in your ScriptRunner version.
Do IssueFunction examples work the same in Jira Cloud and self-managed Jira?
Not necessarily. ScriptRunner’s functions and supported syntax can vary by Jira product, deployment, and app version. Before using an example in a shared report, verify it in your environment and consult the documentation for your installed edition. Test the query with a small, known set of issues first.
Conclusion
IssueFunction extends JQL with ways to search through relationships such as links, subtasks, parents, and epics. To get reliable results, choose the function for the relationship, test its subquery, and check ScriptRunner compatibility and permissions.
When a relationship-based filter feels frustrating, start small: verify one known issue, confirm the function’s behavior, then widen the query. That approach makes Jira IssueFunction easier to understand and gives your team a clearer path to useful reports.