- Quick assessment
- Overview
- At a glance
- App Internal (4 scopes)
- Issue Data (10 scopes)
- Project Data (3 scopes)
- Jira Software (4 scopes)
- JSM (3 scopes)
- JSM Assets / CMDB (7 scopes)
- Field & Screen Configuration (14 scopes)
- Rovo (1 scope)
- Jira Administration (2 scopes)
- Impersonation in practice
- Reviewing scopes before installing
- Compliance and Trust Center
- Next steps
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
evalbuiltin accepts only the ID of a saved script, never a string of code), nofetch, 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:
- Admin Hardening Guide - Production checklist for Run As, API restrictions, baselines, and retention
- Security Reference for Auditors - Threat model, scope-to-data category mapping, data flow, and GDPR mapping
- Trust Center - SOC 2 Type II, GDPR, DPAs, vulnerability disclosure, and certifications
- DPA - JiBrok Studio for Jira Cloud - Data Processing Agreement
- Provider-Specific Terms - Studio - terms specific to JiBrok Studio
- Forge Platform & Security Architecture - tenant isolation, data residency, and egress controls
Next steps
- Admin Hardening Guide - Day 0 / Day 1 / Week 1 production checklist
- Security Reference for Auditors - Threat model, data flow, GDPR mapping, evidence
- Security Overview - Sandbox, API restrictions, execution identity, audit
- Forge Platform & Security Architecture - Platform-level protections
- API Restrictions - Configure endpoint access rules
- Administration - Run As, trigger toggles, and admin controls
- Limits - Resource limits per trigger
- FAQ - Common questions about permissions and security
