Permissions Reference

Quick assessment

A 30-second read for purchasing teams and managers evaluating the app.

  • Forge-native - runs entirely inside Atlassian infrastructure. No external servers, no companion apps, no third-party data stores.
  • 48 declared scopes. The scope list is part of the app manifest published on the Atlassian Marketplace; a release that changes it requires a new Atlassian review and explicit approval by a site administrator before it takes effect.
  • Admin-only install and use - only Jira site administrators can install, configure, write, or edit scripts. Non-admins never see scripts.
  • Sandboxed execution - scripts run in a multi-layer custom interpreter with no dynamic code evaluation (the eval builtin accepts only the ID of a saved script, never a string of code), no fetch, no filesystem, and no module system.
  • Single outbound call - the only network egress is the weekly GDPR report of stored account IDs to Atlassian’s Personal Data Reporting API. Nothing else leaves Atlassian Forge.
  • Two layers of admin control on top - API Restrictions (per-script and global whitelist/blacklist) and Run As policy (which execution identities are allowed).
  • Compliance - JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate. GDPR-aligned, single sub-processor (Atlassian Forge). See Trust Center.

What Studio does NOT request

Studio’s manifest does not include any of the following:

  • Filesystem access of any kind
  • Outbound HTTP to arbitrary URLs (no external: scopes)
  • Jira user email addresses (the email endpoint is permanently blocked at the API gateway)
  • OAuth tokens, API tokens, or admin passwords
  • Cross-site Jira data (each Jira site is a separate Forge installation with isolated storage)
  • Account password resets, 2FA secrets, or session cookies
  • Atlassian Marketplace billing data, vendor analytics, or other vendor APIs

Worst case

If a malicious script is created by a Jira admin, the worst case is bounded by what that admin could already do in Jira directly. Studio cannot escalate beyond the actor’s Jira permissions, cannot reach external services, and cannot bypass tenant isolation. Every settings change is recorded in the Settings audit, and script executions in the Script Runs audit - an admin chooses which trigger types the run audit records, so a compliance review should confirm the ones it cares about are switched on (see Administration). Both logs are append-only: an admin can neither edit nor remove entries. For destructive operations the Application Run As mode is intentionally restricted - see Application actor restrictions.

For setting up a production-ready configuration, follow the Admin Hardening Guide. For a security review, threat model, and DPIA-grade detail, see Security Reference for Auditors.


Overview

JiBrok Studio for Jira Cloud declares 48 OAuth scopes in its Forge manifest. The list is shown to your Jira admin during installation and again whenever a release changes it - such a release goes through a new Atlassian review and requires explicit administrator approval.

This page lists every scope by name, explains what it enables, and shows whether it runs as the app or as a real user (impersonation). It is a companion to the higher-level Security Overview and the platform-level Forge Platform & Security Architecture.

Why so many scopes

Atlassian intentionally splits broad permissions into narrow, single-purpose scopes. Reading an issue, reading its status, reading its priority, and reading its labels are four separate scopes - the app cannot ask for one “full access” permission instead. The number of scopes reflects the surface area of features Studio supports (issue automation, scripted custom fields, JSM Assets, sprints, UI modifications, Rovo) - not the level of access per scope.

What “Impersonation” means in this page

Some scopes are declared with allowImpersonation: true in the manifest. When a script runs as the current user or as a specific user, those calls inherit that user’s Jira permissions and are attributed to that user in Jira’s audit trail. Scripts cannot escalate beyond what the actor can do in Jira.

Scopes marked App-only never use impersonation. They run with app-level permissions and are reserved for admin-time configuration tasks (registering UI modifications, creating scripted custom fields) where a per-call user identity is not meaningful.

See Execution identity for how admins control who scripts run as.


At a glance

Category Count Impersonation What it enables
App Internal 4 App-only Storage, UI Modification registration, GDPR reporting, license check
Issue Data 10 All impersonation Read and write issues, comments, transitions, links from scripts
Project Data 3 All impersonation Read projects, components, versions from scripts
Jira Software 4 Mixed Epics (impersonation); boards and sprints (app-only)
JSM 3 App-only Read and write service desk requests and manage JSM customers from scripts; read request types for UIM and recipe configuration
JSM Assets / CMDB 7 All impersonation Read, write, delete Assets objects and their schemas
Field & Screen Configuration 14 App-only Power the Scripted Custom Fields module
Rovo 1 App-only Receive Rovo agent invocations
Jira Administration 2 App-only UIM context registration and admin configuration access
Total 48 21 impersonation / 27 app-only  

App Internal (4 scopes)

These scopes power Studio’s own storage, lifecycle, and licensing. They never read or write Jira project data on behalf of a user.

Scope Impersonation What it enables Why Studio needs it
storage:app App-only Read and write the app’s own Forge storage (SQL and key-value) Scripts, run history, audit records and custom API restriction profiles live in Forge SQL; settings, folder and label metadata and the parsed script cache live in Forge KV - all isolated per Jira site
write:app-data:jira App-only Register UI Modifications with Jira Creates and removes UIM contexts when you enable a UIM trigger on a script
report:personal-data App-only Submit GDPR personal data reports to Atlassian Reports the account IDs Studio stores to Atlassian once a week, so Atlassian can propagate account closures and updates back to the app
read:license:jira App-only Read the app’s license status Gates premium features and shows correct license state in the admin UI; see FAQ for behavior on license expiry

Issue Data (10 scopes)

All Issue Data scopes are declared with allowImpersonation: true. This is the heart of script execution: every read and write your scripts perform on issues passes through this category.

Scope Impersonation What it enables Why Studio needs it
read:jira-work Yes Read issues, search issues, JQL queries Backs Issues.search, Issues.get, and any script that reads issue data
write:jira-work Yes Create, update, transition, link, delete issues; add comments Backs Issues.create, issue.update, issue.transition, issue.addComment, and similar mutating operations in scripts
read:jira-user Yes Look up Jira users Backs Users.current, Users.get, Users.find, assignee selection in scripts
read:issue:jira Yes Granular read of issue fields Required alongside read:jira-work for the newer granular Jira API
read:issue-details:jira Yes Read extended issue detail fields Granular companion needed for full issue payloads
read:issue-status:jira Yes Read available statuses Backs JQL by status and status checks before transitions
read:issue-type:jira Yes Read available issue types Lets scripts pick a valid issue type when creating issues
read:priority:jira Yes Read priority definitions Required to set priority on issue create or update
read:label:jira Yes Read issue labels Lets scripts read and filter by label
read:user:jira Yes Granular read of user accounts Granular companion to read:jira-user

Project Data (3 scopes)

All Project Data scopes are declared with allowImpersonation: true.

Scope Impersonation What it enables Why Studio needs it
read:project:jira Yes Read projects, search projects Backs Projects.list and Projects.get
read:project.component:jira Yes Read project components Backs Components.get and component lookups
read:project-version:jira Yes Read project versions Backs Versions.get for fix-version logic

Jira Software (4 scopes)

Jira Software is the only mixed-impersonation category. Board and sprint scopes are declared app-only by design: the Boards and Sprints script APIs run with the app identity, while epic reads follow the configured actor.

Scope Impersonation What it enables Why Studio needs it
read:epic:jira-software Yes Read epic data Lets scripts read the epic link field on issues
read:board-scope:jira-software App-only List and inspect agile boards Backs Boards.list and Boards.get
read:sprint:jira-software App-only Read sprints and their issues Backs Sprints.get and Sprints.getIssues
write:sprint:jira-software App-only Move issues into a sprint Backs Sprints.moveIssues for bulk sprint planning

JSM (3 scopes)

All three JSM scopes are declared app-only: JSM calls run with the app identity rather than the configured actor. They are not admin-time-only - the JSM script namespace is available to scripts, including its write methods.

Scope Impersonation What it enables Why Studio needs it
read:servicedesk-request App-only Read service desks, request types, and customer requests Backs the read side of the JSM script namespace, and lets the UIM editor and the sync recipes pick the right service desk request type when registering a trigger or a sync
write:servicedesk-request App-only Create and update customer requests and their comments Backs the write side of the JSM script namespace - scripts can raise and update customer requests, not only read them
manage:servicedesk-customer App-only Create service desk customers and manage service desk customer lists Lets a script give a requester a customer account on a service desk when they do not have one yet

JSM Assets / CMDB (7 scopes)

All Assets/CMDB scopes are declared with allowImpersonation: true. The Assets API namespace in scripts always executes as the configured actor, so destructive operations like Assets.deleteObject follow the actor’s Jira permissions.

Scope Impersonation What it enables Why Studio needs it
read:cmdb-object:jira Yes Read individual Assets objects, search Assets Backs Assets.getObject and Assets.search
write:cmdb-object:jira Yes Create and update Assets objects Backs Assets.createObject and Assets.updateObject
delete:cmdb-object:jira Yes Delete Assets objects Backs Assets.deleteObject - the call runs as the configured actor, so the deletion is checked and audited against that identity
read:cmdb-schema:jira Yes Read object schemas Required for Assets discovery in scripts
read:cmdb-type:jira Yes Read object types Required to create or filter Assets objects of a given type
read:cmdb-attribute:jira Yes Read attribute metadata Required to set typed attributes correctly when creating Assets objects
read:cmdb-icon:jira Yes Read object icons Required for full object payloads

Field & Screen Configuration (14 scopes)

All Field & Screen Configuration scopes are app-only. They power the Scripted Custom Fields module - creating the field, registering its context, computing values, and placing the field on the right screens.

Scope Impersonation What it enables Why Studio needs it
read:field:jira App-only Read the Jira field catalog Powers field metadata cache and field pickers in the admin UI
read:field-configuration:jira App-only Read field configurations Required to register and update Scripted Custom Field contexts
read:custom-field-contextual-configuration:jira App-only Read custom field per-project configuration Required by the jira:customFieldType module
write:field-configuration:jira App-only Update field configurations Required to wire scripted fields into existing field configurations
write:field.default-value:jira App-only Push computed values into scripted custom fields The mechanism that publishes results from your scripted field formulas back to Jira
write:field:jira App-only Create and update custom fields Required when Studio creates a new scripted custom field
read:screen:jira App-only Read Jira screens Lets the admin UI show screen lists when assigning scripted fields
read:screen-scheme:jira App-only Read screen schemes Required for screen-scheme aware field placement
read:issue-type-screen-scheme:jira App-only Read issue-type-to-screen mappings Required to find where a scripted field can appear
read:screenable-field:jira App-only Read which fields can appear on a screen Required for screen editing safety checks
read:screen-field:jira App-only Read field placement on screens Lets the admin UI know if a scripted field is already on a screen
read:screen-tab:jira App-only Read screen tabs Required to add scripted fields to the right tab
write:screen-tab:jira App-only Add a scripted field to a screen tab Final step of the “place scripted field on a screen” flow
read:user-configuration:jira App-only Read user-level field configuration Required for context-aware field rendering

Rovo (1 scope)

Scope Impersonation What it enables Why Studio needs it
read:chat:rovo App-only Receive Rovo agent invocations Required by the Rovo agent module - lets users run admin-approved scripts from Rovo chat. Each script runs as its Run as setting says - the user talking to Rovo for Current user, otherwise the app or the configured user, the app under the Application actor restrictions

See Rovo AI Agent Integration for setup and the delegation model.

Running exposed scripts from external AI clients over MCP is in preparation and is not part of the current version.


Jira Administration (2 scopes)

Scope Impersonation What it enables Why Studio needs it
manage:jira-configuration App-only Manage Jira-level configuration objects Required for UIM context management and removing stale UIM registrations; also used by the two-project sync recipe to read project, workflow and field schemas during preflight
manage:jira-project App-only Manage per-project configuration Required by jira:uiModifications to register UIM contexts inside a project

Impersonation in practice

JiBrok Studio scripts always run with one of four execution identities, controlled by the admin in Administration:

Mode What it means for scopes
Current User (default) Calls go through the impersonation-enabled scopes as the triggering user. Jira enforces that user’s permissions per call
Specific User Calls go through impersonation-enabled scopes as the configured user. Same Jira-level permission checks as Current User
Pre-configured Users A whitelisted list of users an admin can pick from when configuring a script
Application Calls run as the app. DELETE operations, issue notifications and security-sensitive admin changes (groups, roles, workflow/permission/notification schemes) are blocked at the app’s API gateway - see Application actor restrictions

By default, Current User and Specific User are available. Application and Pre-configured Users must be explicitly enabled by an admin; Specific User can be turned off.


Reviewing scopes before installing

When you install or upgrade JiBrok Studio, Jira shows the full list of scopes the app requests. The list comes directly from the manifest reviewed by Atlassian; it cannot be expanded silently between Marketplace releases. To see the current set without installing, check the app’s listing on the Atlassian Marketplace.

After installation you have two layers of administrative control on top of the declared scopes:

  • API Restrictions - Jira admins can globally and per-script restrict which Jira REST endpoints scripts are allowed to call, even if the scope itself permits the call. See API Restrictions.
  • Run As - the admin chooses which execution identities are available. Limiting scripts to Current User ensures all impersonation-aware scopes are checked against a real Jira user on every call. See Administration.

In addition, every API call passes through a six-level security pipeline (read-only mode, permanent blacklist, app actor restrictions, hardcoded API whitelist, global blacklist, global whitelist). See Security Overview - REST API restrictions for the full pipeline.


Compliance and Trust Center

The full set of declared scopes is part of Atlassian’s app review process and is referenced in our public security documentation:


Next steps


JiBrok Studio for Jira Cloud JiBrok Studio for Jira Cloud
Release notes
Core Features
Triggers
Extensions
Data Storage
Scripting Overview
JavaScript Engine
Python Engine
Groovy Engine
Scripting API
Administration
Guides