Jira IssueFunction: A Practical Guide to JQL Query Filters
Need better Jira filters? This practical guide to issuefunction jira shows how to extend JQL for complex searches. Read now to find issues faster.
Jira’s standard JQL can handle everyday searches, but it may fall short when you need to find issues through relationships, parent-child links, or more advanced conditions. Repeating searches manually takes time, and a small syntax mistake can hide the issues you need.
IssueFunction extends JQL with additional functions, making certain complex searches possible inside Jira. The challenge is knowing which function fits, how its arguments work, and whether it’s available in your Jira setup. But here's the truth: you don’t need to memorize every function to get started. Learn the basic pattern, try a focused example, and validate the results before using a query in a dashboard or workflow.
What IssueFunction Adds to Jira JQL
IssueFunction for Jira is a ScriptRunner feature that adds advanced functions to JQL, helping you search for issues through relationships and conditions that standard JQL may not cover. You typically use it with syntax such as issueFunction in functionName("subquery"), though each function can have different arguments.
For example, a query can find parent issues whose subtasks match a condition, or issues linked to a set of search results. That lets you search across issue relationships without opening every issue individually.
Here's why: IssueFunction works alongside JQL rather than replacing it. Your usual project, status, assignee, and date conditions can still narrow the results.

How the query pattern works
The keyword issueFunction tells Jira to evaluate a ScriptRunner function. The function name identifies the search operation, while its arguments provide details such as a JQL subquery or relationship type.
For example, issueFunction in parentsOf("project = APP AND status = Open") asks for parent issues of matching open issues in the APP project. Check the syntax supported by your ScriptRunner edition before using this example.
What it can help you find
Depending on your ScriptRunner edition and available functions, you may be able to search for parent issues, subtasks, linked issues, epic relationships, or issues matching more specialized conditions.
That’s useful when a project lead needs to find open parent work connected to blocked subtasks, or when a team wants to inspect issues linked to a particular search result.
Build an IssueFunction Query Step by Step
Start with the result you need, then choose a function that follows the relevant relationship. Keeping the first query small makes it easier to spot syntax mistakes and unexpected matches.
Describe the result. Write down what you want returned. For example, “Find parent issues whose subtasks are still open.”
Choose a matching function. Look for a function that searches parent issues, subtasks, linked issues, or another relevant relationship in your ScriptRunner edition.
Write the subquery. Use ordinary JQL to define the issues the function should inspect. For example, project = APP AND status = Open.
Add the function to JQL. A parent search might look like issueFunction in parentsOf("project = APP AND status = Open"). Confirm the function name and argument format in your installed version.
Run the search and check the results. Open several returned issues and verify that each matches the relationship and conditions you intended.
Add restrictions gradually. Add project, status, or assignee conditions one at a time. This makes it easier to identify which clause changes the result set.
The best part? You can test the relationship first, then add detail. If a broad query returns too many issues, a project or status condition can make it more useful.
Example: Find parent work tied to open subtasks
Suppose a release team wants to review parent issues that still have open subtasks. Start by defining the subtasks: project = APP AND status != Done. Then use the appropriate parent-search function supported by your ScriptRunner edition.
Once the results look right, add a release label or another constraint if needed. This gives the team a focused review queue instead of requiring someone to inspect each parent issue manually.
Useful Search Patterns and When to Use Them
IssueFunction is most valuable when the relationship between issues matters as much as their individual fields. Choose a pattern that matches the question you’re asking, rather than forcing one function to handle unrelated searches.
Search across parent and child relationships
A parent-search function can help you locate higher-level work connected to issues that meet a condition. A subtask-search function can help you find child issues associated with a parent-level search.
For example, a support team might search for subtasks under issues assigned to a particular service owner. The exact function and accepted JQL can vary, so confirm the syntax in your ScriptRunner edition.
Search through issue links
Link searches are helpful when teams use relationships such as “blocks,” “is blocked by,” or “relates to.” A query can start with a standard JQL search and return issues linked to its matches.
Imagine a release coordinator searching for issues linked to all unresolved release blockers. A linked-issue function can help surface connected work that a simple status filter would miss.
Combine an advanced function with standard JQL
You can often narrow an IssueFunction result with ordinary JQL conditions, such as a project, assignee, or status. This is useful when a relationship search initially covers several teams or workstreams.
Let me explain: first find the relationship you care about, then limit the returned issues. If you add too many conditions before confirming the function works, troubleshooting becomes harder.
Validate Queries and Avoid Common Syntax Traps
A query can be syntactically valid and still return the wrong issues. Check both the function’s behavior and the real issue relationships in your Jira project before relying on results.
Confirm function availability and syntax
ScriptRunner functions can differ across Jira editions, versions, and deployment types. A function available in one setup may use different syntax or may not be available in another.
Check the function reference for your installed edition, especially when moving a query between Jira Cloud and Data Center. Don’t assume a copied query will behave identically in every environment.
Keep subqueries focused
A broad subquery can make an advanced search slow or difficult to interpret. For instance, searching every issue across a large Jira instance may take longer than limiting the search to one project.
Start with a project and a clear condition, then expand only when the results require it. A smaller search also makes it easier to compare returned issues with your expected results.
Check permissions and relationship data
Your Jira permissions affect what you can see, and issue relationships must be present for link-based searches to return connected work. If an expected issue is missing, check both access and the relationship itself.
You might be wondering: did the function fail, or is the relationship absent? Open a few relevant issues and inspect their links, parent, or subtask details before changing the query.
Use IssueFunction in Dashboards and Team Workflows
Once a query is reliable, you can use it to support recurring project work. A release dashboard might show parent issues connected to open blockers, while a triage view might surface linked issues that need review.
Before adding a query to a shared dashboard, make sure its scope is clear. A filter named “Open release parents” is more useful than one called “Advanced search,” especially when teammates need to understand its purpose.

Test before sharing
Run the query in Jira and inspect representative results. If teammates will use the filter, ask someone with the intended permissions to check whether they see the same issues.
For a recurring workflow, record what the filter should include and who maintains it. That small step helps prevent confusion when project statuses, issue links, or team conventions change.
Know when a simpler query is enough
Not every search needs an advanced function. If standard JQL can answer the question clearly, a simpler filter may be easier for your team to understand and maintain.
Use IssueFunction when the relationship or condition genuinely requires it. For example, searching all open issues in one project may need only standard JQL, while finding parents of matching subtasks may call for an advanced function.
ONES.com brings project management and knowledge management together through separate products: ONES Project for project management and ONES Wiki for knowledge management. Teams considering a Jira alternative can review ONES Project’s workflows and built-in capabilities against their current requirements.

ONES Project supports Jira-compatible workflows, custom workflows and fields, sprint management, automation, and built-in reporting. It is sold separately from ONES Wiki, so a team can choose the product that fits its needs.
Core capabilities
Issue tracking requires connected team workflows: ONES Project supports Jira-compatible workflows, helping teams carry familiar work patterns into a different project management environment.
Rigid processes make exceptions harder to manage: Custom workflows let teams shape work stages around their delivery process, helping issues reflect how the team actually operates.
Standard fields don’t capture every project detail: Custom fields let teams track information specific to their work, so important context can stay alongside the issue.
Sprint planning needs a clear home: Sprint management supports teams organizing and following iterative work within their project management workflow.
Repeated manual actions take time: Automation can handle supported routine actions, helping teams reduce repetitive work.
Teams need visibility into progress: Built-in reporting gives teams reporting capabilities within ONES Project, reducing reliance on additional reporting add-ons for supported needs.
Plugin-heavy setups can add maintenance: Native capabilities for workflows, fields, sprint management, automation, and reporting can reduce the need for plugins where those features meet team requirements.
Deployment requirements vary: ONES.com offers Cloud, On-Premise, Private Cloud, and Air-gapped deployments, with full feature parity between its cloud and self-hosted versions.
Where teams might consider ONES Project
A software team that currently relies on Jira-compatible workflows could assess ONES Project when reviewing project management options. It can compare custom fields, sprint management, automation, and reporting against the team’s actual processes.
A team with strict hosting requirements might also evaluate the available deployment choices, including On-Premise, Private Cloud, or Air-gapped deployment. ONES.com offers a free plan for up to 30 seats, which can help a team assess fit before making a broader decision.
ONES Project and ONES Wiki are sold separately. A team that wants both project management and knowledge management can consider them as distinct products rather than assuming they come as one bundled product.
Common Challenges with IssueFunction Queries
The query returns no results
Problem: A function may have the wrong name, an incorrect subquery, or no matching issue relationships. Permissions can also affect what appears in your results.
Solution: Test the subquery by itself, confirm the function syntax for your ScriptRunner edition, then check parent, subtask, or link details on a few expected issues.
The results include too many issues
Problem: A broad subquery can include matches across multiple projects or teams, making the search difficult to use.
Solution: Add a project, status, or other clear restriction to the subquery. Check the result count after each change so you can see which condition narrows the search.
The query works in one Jira setup but not another
Problem: Function availability and syntax can vary by ScriptRunner edition, version, or deployment type.
Solution: Review the documentation for the destination setup and test the query there. Update the function or rewrite the search to match the supported syntax.
The search is difficult for teammates to maintain
Problem: A complex filter with an unclear name can become hard to interpret after its creator moves to another task or team.
Solution: Use a descriptive filter name and explain what the query returns. Keep the search focused, and identify who should review it when project conventions change.
FAQs About IssueFunction in Jira
Is IssueFunction included in standard Jira JQL?
No. IssueFunction is provided by ScriptRunner, an app that adds advanced JQL functions. Standard Jira JQL remains available, but you need a compatible ScriptRunner setup to use IssueFunction queries. Check the app’s availability, edition, and syntax for your Jira deployment before building a filter around a specific function.
What does issueFunction in mean?
It is the JQL pattern used to call a ScriptRunner function. The function name follows in, and its arguments define what the function should search. For example, some functions take a JQL subquery. The exact arguments depend on the function, so verify its requirements in the reference for your installed edition.
Can I use IssueFunction in Jira Cloud?
Availability depends on the ScriptRunner product and functions supported for your Jira Cloud setup. Cloud and Data Center can differ in supported functions and syntax, so a query that works in one environment may need changes in another. Check the current ScriptRunner guidance for your edition and test the query before sharing it.
Why is my IssueFunction query slow?
A broad subquery or a large number of issue relationships can make an advanced search take longer. Try limiting the search to a relevant project or status, and confirm that the function is appropriate for the relationship you need. If the query remains slow, review your ScriptRunner edition’s guidance and ask your Jira administrator to assess it.
Conclusion
IssueFunction extends Jira JQL with advanced searches for relationships and conditions that standard queries may not cover. Start by defining the result you want, choosing a suitable function, and testing a focused subquery.
Then check the returned issues, permissions, and ScriptRunner compatibility before sharing the filter. A clear query can make recurring work easier to track, while a simpler JQL search remains the better choice when it answers the question.
If your team is also reviewing its project management setup, compare your workflow needs with options such as ONES Project. The right approach is the one your team can understand, validate, and maintain.