Guides
Signup For Free

Jira API Integration

Suggest Edits

These are the list of integration use cases supported by Knit for Jira API as part of the TICKETING category

Delete a Group

  • ID: delete_a_group
  • Operation: write
  • Entities: group, restriction, comment
  • Summary: This API deletes a group in the system. It requires authentication via basicAuth or OAuth2. The request can specify the group to delete using either the 'groupname' or 'groupId' query parameter, but not both. Additionally, restrictions can be transferred to another group using 'swapGroup' or 'swapGroupId', but not both. The API returns different status codes based on the outcome: 200 for success, 400 if the group name is not specified, 401 for authentication issues, 403 for permission issues, and 404 if the group is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Delete Comment from Issue

  • ID: delete_comment_from_issue
  • Operation: write
  • Entities: issue, permission, comment
  • Summary: This API deletes a comment from a specified issue in Jira. The user must have the necessary permissions to delete the comment, which includes 'Delete all comments' or 'Delete own comments' project permissions. The API requires the issue ID or key and the comment ID as path parameters. An optional query parameter 'parentId' can be included. The request must be authenticated using either Basic Auth or OAuth2. A successful request returns a 204 status code, while various error codes indicate issues such as lack of permissions, incorrect authentication, or non-existent resources.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Delete Issue

  • ID: delete_issue
  • Operation: write
  • Entities: issue, project, subtask
  • Summary: The Delete Issue API allows users to delete an issue in Jira. The issue cannot be deleted if it has one or more subtasks unless the deleteSubtasks query parameter is set to true, which will delete the subtasks along with the issue. The API can be accessed anonymously, but requires the user to have 'Browse projects' and 'Delete issues' project permissions, and if issue-level security is configured, the user must have permission to view the issue. The API takes the issue ID or key as a path parameter and an optional query parameter deleteSubtasks to specify whether to delete subtasks. The response includes status codes indicating success or various error conditions such as lack of permissions or incorrect credentials.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Delete Issue Type

  • ID: delete_issue_type
  • Operation: write
  • Entities: issue type
  • Summary: The Delete Issue Type API allows you to delete an issue type in Jira. If the issue type is currently in use, all instances of it will be updated to use an alternative issue type specified by the alternativeIssueTypeId query parameter. The API requires the id path parameter to specify which issue type to delete. Authentication is required, and can be provided via Basic Auth or OAuth2. The API returns a 204 status code if successful, and various error codes for different failure scenarios, such as 400 if issues cannot be updated, 401 for authentication errors, 403 for permission issues, 404 if the issue type or alternative is not found, and 409 for conflicts with the issue type and alternative issue type.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Remove User from Group

  • ID: delete_remove_user_from_group
  • Operation: write
  • Entities: group, user
  • Summary: The 'Remove User from Group' API allows you to remove a user from a specified group in Jira. The API requires authentication via basic auth or OAuth2. You must provide either the 'groupname' or 'groupId' as a query parameter to identify the group, but not both. The 'accountId' of the user to be removed is required. The API returns a 200 status code if successful, and various error codes for missing parameters, incorrect authentication, insufficient permissions, or if the group or user is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Reset User Default Columns

  • ID: delete_reset_user_default_columns
  • Operation: write
  • Entities: permission, column, user
  • Summary: This API resets the default issue table columns for a user to the system default. If the 'accountId' query parameter is not provided, the default columns for the calling user are reset. The API requires 'Administer Jira' global permission to set the columns for any user, or permission to access Jira to set the calling user's columns. The API supports basic authentication. A successful request returns a 204 status code. If authentication credentials are incorrect or missing, a 401 status code is returned. A 403 status code is returned if the user lacks the necessary permissions or is not accessing their own user record.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Delete User from Jira

  • ID: delete_user_from_jira
  • Operation: write
  • Entities: user
  • Summary: This API deletes a user from Jira's user base. It requires the account ID of the user to be specified as a query parameter. The operation does not delete the user's Atlassian account, only their presence in Jira. The API uses basic authentication with an email and API token. If successful, it returns a 204 status code. Possible error responses include 400 if the user cannot be removed, 401 for incorrect or missing authentication, 403 for insufficient permissions, and 404 if the user is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Delete User Property

  • ID: delete_user_property
  • Operation: write
  • Entities: user, property
  • Summary: The Delete User Property API allows you to delete a property from a user in Jira. To perform this operation, you need to have the 'Administer Jira' global permission to delete a property from any user, or access to Jira to delete a property from your own user record. The API requires the 'propertyKey' as a path parameter and 'accountId' as a query parameter. The 'userKey' and 'username' query parameters are deprecated and will be removed soon. The API uses basic authentication or OAuth2 for security. A successful deletion returns a 204 status code with no response body. Errors may include 400 if 'accountId' is missing, 401 for incorrect or missing authentication, 403 for insufficient permissions, and 404 if the user or property is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Account IDs for Users

  • ID: get_account_ids_for_users
  • Operation: read
  • Entities: key, account ID, user
  • Summary: This API endpoint retrieves the account IDs for users specified by either the 'key' or 'username' query parameters. It supports pagination with 'startAt' and 'maxResults' parameters. The request requires authentication via basicAuth or OAuth2 with 'read:jira-user' scope. The response includes an array of objects, each containing a 'username' and 'accountId'. If neither 'key' nor 'username' is provided, or if both are provided, the request will fail. The API returns a 200 status code with the user account IDs if successful, a 400 status code if the request parameters are incorrect, and a 401 status code if authentication fails.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get All Issue Events

  • ID: get_all_issue_events
  • Operation: read
  • Entities: issue, event
  • Summary: This API endpoint retrieves all issue events from the Jira system. It requires authentication via basic auth or OAuth2. The request must include an 'Accept' header specifying 'application/json'. The response will be a JSON array of issue events, each containing an 'id' and 'name'. If the request is successful, a 200 status code is returned along with the list of events. If authentication fails, a 401 status code is returned. If the user lacks permission, a 403 status code is returned.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get All Issue Types

  • ID: get_all_issue_types
  • Operation: read
  • Entities: project, issue type, user
  • Summary: This API endpoint retrieves all issue types available in Jira. It can be accessed anonymously, but the results depend on the user's permissions. If the user has the 'Administer Jira' global permission, all issue types are returned. If the user has the 'Browse projects' project permission for one or more projects, only the issue types associated with those projects are returned. The request requires an 'Accept' header specifying the media type, and optionally an 'Authorization' header for authentication. The response includes details about each issue type, such as its ID, name, description, icon URL, and whether it is a subtask.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get All Labels

  • ID: get_all_labels
  • Operation:
  • Entities:
  • Summary: The Get All Labels API returns a paginated list of labels from the Jira system. It accepts query parameters 'startAt' and 'maxResults' to control pagination. The 'startAt' parameter specifies the index of the first item to return, with a default value of 0, while 'maxResults' specifies the maximum number of items to return per page, with a default value of 1000. The response includes pagination details such as 'isLast', 'maxResults', 'nextPage', 'self', 'startAt', 'total', and 'values', which is an array of label strings. The API requires authentication via basicAuth or OAuth2 with 'read:jira-work' scope.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get All Project Roles

  • ID: get_all_project_roles
  • Operation: read
  • Entities: project, actor, project role
  • Summary: This API retrieves a list of all project roles in Jira Cloud, including details about each role and its default actors. Project roles are a flexible way to associate users and groups with projects, and they are used in various schemes such as permission schemes, email notification schemes, issue security levels, comment visibility, and workflow conditions. The response includes detailed information about each project role, such as its ID, name, description, scope, and associated actors. The actors can be either groups or users, and they can be set as default members for all newly created projects or specific to a project.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get All Users

  • ID: get_all_users
  • Operation: read
  • Entities: user
  • Summary: The Get All Users API returns a list of all users, including active, inactive, and previously deleted users with an Atlassian account. Privacy controls are applied to the response based on user preferences, which may hide certain information like email addresses. The API accepts query parameters 'startAt' and 'maxResults' to paginate the results, with defaults of 0 and 50, respectively. The response includes user details such as accountId, accountType, active status, avatar URLs, displayName, and self URL. The API requires authentication via basicAuth or OAuth2 with 'read:jira-user' scope.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Alternative Issue Types

  • ID: get_alternative_issue_types
  • Operation: read
  • Entities: field configuration scheme, issue type, workflow scheme
  • Summary: This API returns a list of issue types that can be used to replace a specified issue type. The alternative issue types are those assigned to the same workflow scheme, field configuration scheme, and screen scheme. The API can be accessed anonymously. The request requires the 'id' path parameter, which is the ID of the issue type to be replaced. The response includes an array of issue types, each with details such as 'avatarId', 'description', 'hierarchyLevel', 'iconUrl', 'id', 'name', 'self', 'subtask', and optionally 'entityId' and 'scope'.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Bulk Get Groups

  • ID: get_bulk_groups
  • Operation: read
  • Entities: group
  • Summary: The Bulk Get Groups API returns a paginated list of groups. It accepts several query parameters such as 'startAt' for pagination offset, 'maxResults' for the number of items per page, 'groupId' and 'groupName' for filtering specific groups by ID or name, 'accessType' for filtering by access level, and 'applicationKey' for filtering by application key. The response includes pagination details and a list of groups with their IDs and names. The API requires authentication via basicAuth or OAuth2 with 'read:jira-user' scope.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Bulk Get Users

  • ID: get_bulk_users
  • Operation: read
  • Entities: pagination, account ID, user
  • Summary: The Bulk Get Users API returns a paginated list of users specified by one or more account IDs. The API requires the 'accountId' query parameter to specify the users to retrieve. Optional query parameters include 'startAt' for the page offset and 'maxResults' for the number of items per page. Deprecated parameters 'username' and 'key' are also present but will be removed soon. The response includes user details such as account ID, account type, active status, avatar URLs, display name, email address, and time zone. The API supports basic authentication and OAuth2 with 'read:jira-user' scope.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Comment from Issue

  • ID: get_comment_from_issue
  • Operation: read
  • Entities: issue, user, comment
  • Summary: This API endpoint retrieves a specific comment from an issue in Jira. It requires the issue ID or key and the comment ID as path parameters. Optionally, the 'expand' query parameter can be used to include additional information such as the rendered body of the comment. The response includes details about the comment's author, body, creation and update timestamps, and visibility settings. The operation can be accessed anonymously, but appropriate permissions are required to view the comment.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Comments for an Issue

  • ID: get_comments_for_an_issue
  • Operation: read
  • Entities: issue, user, comment
  • Summary: This API endpoint retrieves all comments for a specified issue in Jira. It requires the issue ID or key as a path parameter. The response can be paginated using the 'startAt' and 'maxResults' query parameters. The 'orderBy' query parameter allows sorting by the comment creation date. The 'expand' query parameter can be used to include additional information, such as rendering the comment body in HTML. The response includes details about each comment, such as the author, body, creation and update timestamps, and visibility settings. The API supports anonymous access but requires appropriate permissions to view comments.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Create Field Metadata for a Project and Issue Type ID

  • ID: get_create_field_metadata_for_a_project_and_issue_type_id
  • Operation: read
  • Entities: field metadata, project, issue type
  • Summary: This API endpoint retrieves a page of field metadata for a specified project and issue type ID. It is used to gather information necessary to populate requests for creating issues. The endpoint can be accessed anonymously and requires the project ID or key and the issue type ID as path parameters. Optional query parameters include 'startAt' for pagination and 'maxResults' to limit the number of items per page. The response includes metadata about fields such as field ID, name, operations allowed, and whether the field is required. The response also provides pagination details like 'maxResults', 'startAt', and 'total'.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Create Issue Metadata

  • ID: get_create_issue_metadata
  • Operation: read
  • Entities: field, project, issue type
  • Summary: The Get Create Issue Metadata API returns details of projects, issue types within projects, and optionally, the create screen fields for each issue type for the user. It is used to gather information necessary for creating issues in Jira. The API can be accessed anonymously and allows filtering by project IDs, project keys, issue type IDs, and issue type names through query parameters. The response includes metadata for valid projects and issue types, and can be expanded to include additional field information. The API is deprecated and will be removed in the future.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Create Metadata Issue Types for a Project

  • ID: get_create_metadata_issue_types
  • Operation: read
  • Entities: project, issue type
  • Summary: This API returns a page of issue type metadata for a specified project. It is used to gather information necessary for creating issues in a project. The API can be accessed anonymously and requires the project ID or key as a path parameter. Optional query parameters include 'startAt' for pagination and 'maxResults' to limit the number of items per page. The response includes a list of issue types with details such as description, icon URL, ID, name, and whether it is a subtask. The response also provides pagination details like 'maxResults', 'startAt', and 'total'.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Edit Issue Metadata

  • ID: get_edit_issue_metadata
  • Operation: read
  • Entities: issue, field, workflow
  • Summary: The Get Edit Issue Metadata API returns the edit screen fields for a specified issue that are visible to and editable by the user. It checks various conditions such as field availability on a screen, visibility in field configuration, and workflow permissions. The API can be accessed anonymously, but requires appropriate permissions to view and edit fields. It accepts path parameters for the issue ID or key, and optional query parameters to override screen security and editable flag checks. The response includes the fields that can be edited, along with their properties and allowed operations.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Groups by Query String

  • ID: get_find_groups_by_query_string
  • Operation: read
  • Entities: group
  • Summary: The 'Find Groups by Query String' API returns a list of groups whose names contain a specified query string. It is primarily used to populate a group picker suggestions list. The API supports various query parameters such as 'query' to specify the search string, 'exclude' and 'excludeId' to exclude specific groups or group IDs, 'maxResults' to limit the number of results, and 'caseInsensitive' to perform a case-insensitive search. The response includes a list of groups with the matched query term highlighted in the group name, a header indicating the number of matching groups, and the total count of matching groups. This API can be accessed anonymously, but requires the 'Browse users and groups' global permission for non-exact matches.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users

  • ID: get_find_users
  • Operation: read
  • Entities: search string, user, property
  • Summary: The Find Users API allows you to search for active users in the system based on a search string and property. It supports filtering users by attributes such as displayName and emailAddress, and can be accessed anonymously. The API applies privacy controls based on user preferences, which may hide certain information like email addresses. The query parameters include 'query', 'username', 'accountId', 'startAt', 'maxResults', and 'property'. The response returns a list of users with details such as accountId, accountType, active status, avatar URLs, displayName, and self URL. The API handles errors for missing required parameters, invalid property parameters, incorrect authentication, and rate limits.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users and Groups

  • ID: get_find_users_and_groups
  • Operation: read
  • Entities: group, project, user
  • Summary: The Find Users and Groups API returns a list of users and groups that match a given search string. The search string is used to find case-insensitive matches for user display names and email addresses, and case-sensitive matches for group names. The API allows optional refinement of the search to specific projects and issue types associated with a custom field, and can exclude Connect app users and groups. The response includes an HTML field for each list, highlighting the matched query term, and a header indicating the number of matching groups or users. The API can be accessed anonymously and supports various query parameters to customize the search.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users by Structured Query

  • ID: get_find_users_by_structured_query
  • Operation: read
  • Entities: query, project, user
  • Summary: This API endpoint allows you to find users by executing a structured query. It returns a paginated list of user details based on the query provided. The query can specify conditions such as users being assignees, reporters, watchers, voters, commenters, or transitioners of specific issues or projects. The API supports complex queries using AND/OR operators. The request requires a query parameter and optionally supports pagination through 'startAt' and 'maxResults'. The response includes user details if successful, or error messages if the request fails due to invalid query, authentication issues, permission issues, or timeout.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users with Browse Permission

  • ID: get_find_users_with_browse_permission
  • Operation: read
  • Entities: issue, project, user
  • Summary: This API endpoint allows you to find users who have permission to browse issues in Jira. You can search for users by matching their attributes against a query string or by specifying their account ID. The search can be scoped to a specific issue or project using the issueKey or projectKey parameters. The results are paginated and privacy controls are applied based on user preferences. The API can be accessed anonymously and supports basic authentication and OAuth2. The response includes user details such as account ID, display name, and avatar URLs.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Changelogs

  • ID: get_issue_changelogs
  • Operation: read
  • Entities: issue, changelog, user
  • Summary: The Get Issue Changelogs API returns a paginated list of all changelogs for a specified issue, sorted by date from the oldest. It requires the issue ID or key as a path parameter. Optional query parameters include 'startAt' for the page offset and 'maxResults' for the number of items per page. The response includes pagination details and a list of changelog entries, each with details about the author, creation date, and changes made. The API can be accessed anonymously but requires appropriate project and issue-level permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Details

  • ID: get_issue_details
  • Operation: read
  • Entities: issue, project, user
  • Summary: The Get Issue Details API returns the details for a specific issue identified by its ID or key. If the identifier doesn't match an issue, a case-insensitive search and check for moved issues is performed. The API can be accessed anonymously and requires the 'Browse projects' permission for the project that the issue is in. If issue-level security is configured, issue-level security permission is needed to view the issue. The API accepts several query parameters such as 'fields' to specify which fields to return, 'fieldsByKeys' to determine if fields are referenced by keys, 'expand' to include additional information, 'properties' to specify issue properties to return, 'updateHistory' to add the project to the user's Recently viewed list, and 'failFast' to determine if the request should fail quickly in case of an error. The response includes detailed information about the issue, including fields, attachments, sub-tasks, comments, issue links, worklogs, and time tracking details.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Limit Report

  • ID: get_issue_limit_report
  • Operation: read
  • Entities: issue, field, limit
  • Summary: The Get Issue Limit Report API returns all issues that are breaching and approaching per-issue limits. It requires the 'Browse projects' project permission and 'Administer Jira' global permission. The API accepts a query parameter 'isReturningKeys' to return issue keys instead of issue ids. The request body can include 'issuesApproachingLimitParams' to specify fields and their approaching limit thresholds. The response includes lists of issues approaching and breaching limits, along with the defined limits for each field.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Picker Suggestions

  • ID: get_issue_picker_suggestions
  • Operation: read
  • Entities: issue, query string, suggestion
  • Summary: The Get Issue Picker Suggestions API returns lists of issues matching a query string. It provides auto-completion suggestions when a user is searching for an issue using a word or string. The API returns two lists: 'History Search', which includes issues from the user's history that contain the query string, and 'Current Search', which includes issues that match the JQL expression in 'currentJQL' and contain the query string. The API can be accessed anonymously and supports various query parameters such as 'query', 'currentJQL', 'currentIssueKey', 'currentProjectId', 'showSubTasks', and 'showSubTaskParent'. The response includes a list of issues suggested for auto-completion.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Security Level Members

  • ID: get_issue_security_level_members
  • Operation: read
  • Entities: issue security scheme, member, issue security level
  • Summary: This API retrieves the members of issue security levels within a specified issue security scheme. It is applicable only to classic projects. The request requires the 'issueSecuritySchemeId' as a path parameter, which identifies the issue security scheme. Optional query parameters include 'startAt' for pagination, 'maxResults' to limit the number of results per page, 'issueSecurityLevelId' to filter by specific security levels, and 'expand' to include additional information in the response. The response includes details about whether it is the last page, the maximum results, the starting index, total items, and a list of issue security level members with their details.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Transitions

  • ID: get_issue_transitions
  • Operation: read
  • Entities: issue, project, transition
  • Summary: The Get Issue Transitions API returns all transitions or a specific transition that can be performed by the user on a given issue, based on the issue's status. The API requires the 'Browse projects' permission for the project containing the issue, and if issue-level security is configured, the user must have permission to view the issue. The API can be accessed anonymously, but if the user lacks the 'Transition issues' permission, no transitions will be listed. The API accepts path parameters for the issue ID or key, and optional query parameters to expand transition details, specify a transition ID, and control the inclusion and sorting of transitions. The response includes a list of transitions with details about each transition's fields, availability, and destination status.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Type Details

  • ID: get_issue_type_details
  • Operation: read
  • Entities: issue type
  • Summary: This API retrieves the details of a specific issue type in Jira. It requires the 'id' of the issue type as a path parameter. The request can be made anonymously, but authentication can be provided using basicAuth or OAuth2. The response includes details such as the avatar ID, description, hierarchy level, icon URL, ID, name, self URL, and whether it is a subtask. The API returns a 200 status code if successful, and error codes 400, 401, or 404 for invalid ID, incorrect authentication, or if the issue type is not found or the user lacks permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Types for Project

  • ID: get_issue_types_for_project
  • Operation: read
  • Entities: hierarchy level, project, issue type
  • Summary: This API retrieves the issue types for a specified project. It requires the project ID as a query parameter and optionally allows filtering by issue type level. The response includes details about each issue type, such as its ID, name, description, hierarchy level, and whether it is a subtask. The API can be accessed anonymously and supports basic authentication and OAuth2 for security.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Issue Watchers

  • ID: get_issue_watchers
  • Operation: read
  • Entities: issue, watcher, user
  • Summary: This API retrieves the list of watchers for a specific issue in Jira. It requires the 'Allow users to watch issues' option to be enabled in the Jira configuration. The API can be accessed anonymously, but requires 'Browse projects' permission for the project containing the issue. If issue-level security is configured, appropriate permissions are needed to view the issue. To view details of other users on the watchlist, 'View voters and watchers' permission is required. The request takes the issue ID or key as a path parameter and returns details such as whether the calling user is watching the issue, the number of watchers, and details of each watcher.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Paginated List of Projects

  • ID: get_paginated_list_of_projects
  • Operation: read
  • Entities: project, permission, category
  • Summary: This API endpoint retrieves a paginated list of projects visible to the user. It supports anonymous access and requires certain permissions for different actions. The API accepts various query parameters to filter and sort the projects, such as 'startAt', 'maxResults', 'orderBy', 'id', 'keys', 'query', 'typeKey', 'categoryId', 'action', 'expand', 'status', 'properties', and 'propertyQuery'. The response includes pagination details and a list of projects with their attributes like 'id', 'key', 'name', 'avatarUrls', 'insight', 'projectCategory', and more. The API returns a 200 status code for successful requests, with possible error codes including 400 for invalid requests, 401 for authentication issues, and 404 if no projects match the search criteria.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Project Role Details and Actors

  • ID: get_project_role_details_and_actors
  • Operation: read
  • Entities: role, project, actor
  • Summary: This API retrieves the details of a specific project role and the associated actors for a given project in Jira. The request requires the project ID or key and the role ID as path parameters. Optionally, you can exclude inactive users by setting the 'excludeInactiveUsers' query parameter. The response includes details about the project role, such as its ID, name, description, and associated actors, which can be either user or group actors. The actors are sorted by display name. The API can be accessed anonymously, and supports basic authentication and OAuth2.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Search for Issues using JQL

  • ID: get_search_for_issues_using_jql
  • Operation:
  • Entities:
  • Summary: The 'Search for Issues using JQL' API allows users to search for issues in Jira using JQL (Jira Query Language). This GET endpoint can be accessed anonymously and provides options for pagination, field selection, and additional data expansion. Users can specify a JQL query to filter issues, use a nextPageToken for pagination, and limit the number of results with maxResults. The fields parameter allows selecting specific fields to return, while the expand parameter can include additional information like rendered fields or changelogs. The API returns a list of issues matching the query, along with metadata like field names and schemas. It supports strong consistency with the reconcileIssues parameter, ensuring that recent updates are reflected in the results.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Default Columns

  • ID: get_user_default_columns
  • Operation: read
  • Entities: permission, column, user
  • Summary: This API endpoint retrieves the default issue table columns for a user in Jira. If the 'accountId' query parameter is not provided, the columns for the calling user are returned. The API requires either the 'Administer Jira' global permission to get column details for any user or permission to access Jira to get the calling user's column details. The response is an array of column items. The API supports basic authentication and OAuth2. If the request is successful, a 200 status code is returned with the column details. If authentication credentials are incorrect or missing, a 401 status code is returned. A 403 status code is returned if the user lacks necessary permissions, and a 404 status code is returned if the requested user is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Details

  • ID: get_user_details
  • Operation: read
  • Entities: group, application role, user
  • Summary: The Get User Details API retrieves information about a user in the Atlassian platform. It requires the 'accountId' query parameter to uniquely identify the user. Optional query parameters include 'expand' to fetch additional user details like groups and application roles. The response includes user details such as account ID, display name, email address, avatar URLs, and more. Privacy controls may hide certain information based on user preferences. The API supports basic authentication and OAuth2 for security.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Email Address

  • ID: get_user_email_address
  • Operation: read
  • Entities: user
  • Summary: This API retrieves a user's email address based on their account ID, regardless of the user's profile visibility settings. It is available for Connect apps approved by Atlassian and Forge apps via asApp() requests. The request requires the 'accountId' as a query parameter, which uniquely identifies the user across all Atlassian products. The response includes the user's account ID and email address if the request is successful. The API requires basic authentication credentials and returns various status codes indicating success, authentication issues, or if the user does not exist.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Email Bulk

  • ID: get_user_email_bulk
  • Operation: read
  • Entities: email address, user, app
  • Summary: The Get User Email Bulk API returns a user's email address regardless of the user's profile visibility settings. It is available for Connect apps approved by Atlassian and Forge apps via asApp() requests. The API requires the 'accountId' query parameter, which is an array of user account IDs. The response includes the user's email information if the request is successful. The API uses basic authentication and returns various status codes, including 200 for success, 400 if the app is not approved, 401 for authentication issues, and 503 if the API is not enabled.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Groups

  • ID: get_user_groups
  • Operation: read
  • Entities: group, user
  • Summary: This API retrieves the groups to which a user belongs in Atlassian products. It requires the 'accountId' query parameter, which uniquely identifies the user. The 'username' and 'key' parameters are deprecated and should not be used. The response includes an array of groups, each with a 'groupId', 'name', and 'self' URL. Authentication is required, and the user must have the 'Browse users and groups' global permission. Possible responses include 200 for success, 401 for authentication issues, 403 for permission issues, and 404 if the user is not found.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find User Keys by Query

  • ID: get_user_keys_by_query
  • Operation: read
  • Entities: issue, query, user
  • Summary: This API endpoint allows you to find user keys by executing a structured query. It returns a paginated list of user keys that match the query criteria. The query can specify roles such as assignee, reporter, watcher, voter, commenter, or transitioner for specific issues or projects. The query can also include user properties. The API supports pagination with 'startAt' and 'maxResult' parameters. The response includes pagination details and a list of user keys. Authentication is required, and the API supports basic authentication and OAuth2.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Property

  • ID: get_user_property
  • Operation: read
  • Entities: user, permission, property
  • Summary: The Get User Property API retrieves the value of a specified user's property using the property key. It requires the 'propertyKey' as a path parameter and 'accountId' as a query parameter. The API returns the property key and its associated value in JSON format. The request must include an 'Accept' header specifying 'application/json'. The response includes the property key and its value if successful. The API requires appropriate permissions, such as 'Administer Jira' for accessing any user's property or access to Jira for accessing the calling user's property.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get User Property Keys

  • ID: get_user_property_keys
  • Operation: read
  • Entities: key, user, property
  • Summary: This API retrieves the keys of all properties for a specified user in Jira. To access the property keys of any user, the caller must have the 'Administer Jira' global permission. If accessing the calling user's property keys, only access to Jira is required. The API requires the 'accountId' query parameter, which uniquely identifies the user across all Atlassian products. The response includes a list of property keys, each with a key and a URL. The API supports basic authentication and OAuth2 with 'read:jira-user' scope.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users Assignable to Issues

  • ID: get_users_assignable_to_issues
  • Operation: read
  • Entities: issue, project, user
  • Summary: This API endpoint returns a list of users that can be assigned to an issue in Jira. It can be used to find users assignable to a new issue by providing the project key or ID, to an updated issue by providing the issue key or ID, or during a transition by providing the issue key or ID and the transition ID. The API supports various query parameters such as 'query', 'accountId', 'project', 'issueKey', 'issueId', 'startAt', 'maxResults', and 'actionDescriptorId'. The response includes user details such as account ID, display name, email address, and avatar URLs. Privacy controls are applied based on user preferences.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users Assignable to Projects

  • ID: get_users_assignable_to_projects
  • Operation: read
  • Entities: issue, project, user
  • Summary: This API endpoint allows you to find users who can be assigned issues in one or more specified projects. It requires the projectKeys parameter and either the query or accountId parameter to be specified. The query parameter is used to match user attributes like displayName and emailAddress, while the accountId parameter matches the user's account ID exactly. The response includes user details such as accountId, displayName, and avatarUrls. Privacy controls are applied based on user preferences, which may hide certain information like email addresses. The API can be accessed anonymously and supports pagination through the startAt and maxResults parameters.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users for Picker

  • ID: get_users_for_picker
  • Operation: read
  • Entities: user
  • Summary: The 'Find Users for Picker' API allows you to search for users whose attributes match a specified query term. The API returns a list of users with the matched query term highlighted in the HTML field. You can specify various query parameters such as 'maxResults' to limit the number of users returned, 'showAvatar' to include the user's avatar URI, and 'excludeAccountIds' to exclude specific users from the results. The response includes the total number of matched users and a list of user details such as account ID, display name, and avatar URL. Privacy controls are applied based on user preferences, and the API can be accessed anonymously.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Users from Group

  • ID: get_users_from_group
  • Operation: read
  • Entities: group, permission, user
  • Summary: This API returns a paginated list of all users in a specified group. Users are ordered by username, but the username is not returned due to privacy reasons. The API requires either the group name or group ID as a query parameter, but not both. Additional query parameters include options to include inactive users, specify the starting index of the results, and set the maximum number of results per page. The response includes pagination details and a list of user details such as account ID, account type, active status, display name, email address, and time zone. The API requires authentication and appropriate permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Users in a Group

  • ID: get_users_in_a_group
  • Operation: read
  • Entities: group, user
  • Summary: This API operation retrieves all users in a specified group. It requires either the group name or group ID as a query parameter, but not both. The response includes the group's ID, name, and a paginated list of users in the group. The API supports expanding additional fields in the response. It requires authentication via basicAuth or OAuth2 with the 'read:jira-user' scope. The operation is deprecated, and it is recommended to use the 'group/member' endpoint instead.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Find Users with Permissions

  • ID: get_users_with_permissions
  • Operation: read
  • Entities: project, permission, user
  • Summary: The 'Find Users with Permissions' API allows you to retrieve a list of users who match a search string and have specific permissions for a project or issue. The API requires either a 'query' or 'accountId' parameter to be specified, along with a mandatory 'permissions' parameter. Optional parameters include 'issueKey', 'projectKey', 'startAt', and 'maxResults'. The response includes user details such as account ID, account type, active status, avatar URLs, display name, and a link to the user's profile. The API can be accessed anonymously, but requires appropriate permissions to retrieve users for any project or specific projects.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Add Attachments to Jira Issue

  • ID: post_add_attachments_to_jira_issue
  • Operation: write
  • Entities: issue, attachment, user
  • Summary: This API endpoint allows users to add one or more attachments to a specified Jira issue. The attachments are uploaded using the multipart/form-data format. The request must include the 'X-Atlassian-Token: no-check' header to bypass CSRF protection. The path parameter 'issueIdOrKey' is required to specify the issue to which the attachments will be added. The request body must include the files to be uploaded, with the multipart/form-data parameter named 'file'. The response returns details of the uploaded attachments, including author information, file metadata, and URLs for accessing the attachments. The operation requires appropriate permissions, such as 'Browse Projects' and 'Create attachments' for the project containing the issue.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Add Comment to Issue

  • ID: post_add_comment_to_issue
  • Operation: write
  • Entities: issue, project, comment
  • Summary: This API adds a comment to a specified issue in Jira. It requires the issue ID or key as a path parameter. The request body must include the comment content and can optionally specify visibility settings. The API supports an optional query parameter 'expand' to include additional information about comments in the response. The response includes details about the comment, such as the author, creation and update timestamps, and visibility settings. The operation can be accessed anonymously, but requires appropriate project permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Add User to Group

  • ID: post_add_user_to_group
  • Operation: write
  • Entities: group, user
  • Summary: This API adds a user to a specified group in Jira. The request requires authentication via basicAuth or OAuth2. The user is identified by their accountId, which is a required field in the request body. The group can be identified either by its name or ID, but not both. The API returns a 201 status code if successful, and various error codes for different failure scenarios, such as missing parameters, authentication issues, or permission errors.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Archive Issues by JQL

  • ID: post_archive_issues_by_jql
  • Operation: write
  • Entities: issue, project, task
  • Summary: The Archive Issues by JQL API allows administrators to archive up to 100,000 issues in a single request using a JQL query. This API is accessible only to signed-in users with Premium or Enterprise licenses and requires Jira admin or site admin permissions. The request body must include a JQL query specifying the issues to archive. Note that subtasks can only be archived through their parent issues, and issues can only be archived from software, service management, and business projects. The API returns a URL to check the status of the submitted request. If the request is invalid, various error responses may be returned, such as 400 for bad requests, 401 for unauthorized access, 403 for forbidden access, and 412 if an archival task is already running.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Bulk Create Issues in Jira

  • ID: post_bulk_create_issues
  • Operation: write
  • Entities: issue, subtask, workflow
  • Summary: This API endpoint allows for the bulk creation of up to 50 issues or subtasks in Jira. It supports setting various fields such as assignee, components, custom fields, description, due date, environment, fix versions, issue type, labels, priority, project, reporter, security, summary, time tracking, and versions. The request body must include an array of issue updates, each containing the fields and optional update details. The response provides details of successfully created issues and any errors encountered during the process. Authentication is required, and the API supports basic authentication and OAuth2.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Bulk Fetch Changelogs for Multiple Issues

  • ID: post_bulk_fetch_changelogs_for_multiple_issues
  • Operation: read
  • Entities: issue, changelog, field
  • Summary: This API endpoint allows users to bulk fetch changelogs for multiple issues in Jira. It returns a paginated list of changelogs for specified issues, sorted by changelog date and issue IDs. Users can specify up to 1000 issue IDs or keys and filter changelogs by up to 10 field IDs. The request body must include the 'issueIdsOrKeys' parameter, and optionally 'fieldIds', 'maxResults', and 'nextPageToken'. The response includes a list of issue changelogs and a token for pagination. The API requires 'Browse projects' permission and, if applicable, issue-level security permission.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Bulk Fetch Issues

  • ID: post_bulk_fetch_issues
  • Operation: read
  • Entities: issue, project, assignee
  • Summary: The Bulk Fetch Issues API allows users to retrieve details for a set of requested issues, up to a maximum of 100 issues per request. Each issue can be identified by its ID or key. The request body must include an array of issue IDs or keys to fetch, and optionally, fields and properties to include in the response. The response includes the details of the requested issues in ascending order by ID, and any errors encountered during the fetch process. This API can be accessed anonymously, but requires appropriate project and issue-level security permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Changelogs by IDs for an Issue

  • ID: post_changelogs_by_ids_for_issue
  • Operation: read
  • Entities: issue, changelog, user
  • Summary: This API returns changelogs for a specified issue by a list of changelog IDs. It requires the issue ID or key as a path parameter and a list of changelog IDs in the request body. The response includes details about each changelog, such as the author, creation time, and changes made. The operation can be accessed anonymously, but requires appropriate project and issue-level security permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Check Issues Against JQL

  • ID: post_check_issues_against_jql
  • Operation: read
  • Entities: issue, project, jql query
  • Summary: This API checks whether one or more issues would be returned by one or more JQL queries. It requires the 'Browse projects' permission for the project that the issue is in, and if issue-level security is configured, the issue-level security permission to view the issue. The request body must include a list of issue IDs and a list of JQL queries. The response returns a list of matched issues or errors for each JQL query, in the order the JQL queries were passed. If the request is successful, a 200 status code is returned with the matched issues. If the number of JQL queries or issue IDs exceeds the maximum allowed, a 400 status code is returned.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Count Issues Using JQL

  • ID: post_count_issues_using_jql
  • Operation: read
  • Entities: issue, query, project
  • Summary: This API provides an estimated count of the issues that match the specified JQL (Jira Query Language). The request requires a JSON object containing a JQL expression, which must be a bounded query for performance reasons. The response returns the count of issues matching the JQL query. The API can be accessed anonymously, but requires 'Browse projects' permission for the project containing the issue, and issue-level security permission if configured. The response includes a count of issues if successful, or error messages if the JQL query cannot be parsed or if authentication credentials are incorrect.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Create Group

  • ID: post_create_group
  • Operation: write
  • Entities: group, user
  • Summary: This API creates a new group in Jira. The request requires the 'name' of the group to be specified in the request body. The request headers must include 'Accept' and 'Content-Type' set to 'application/json'. Upon successful creation, the API returns a 201 status code with details of the created group, including its ID, name, and associated users. If the group name is not specified or already in use, a 400 error is returned. Authentication is required, and the user must have the necessary permissions to create a group.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Create Issue or Subtask in Jira

  • ID: post_create_issue_or_subtask
  • Operation: write
  • Entities: issue, project, subtask
  • Summary: This API endpoint allows you to create an issue or a subtask in Jira. The issue or subtask can be customized using the 'fields' and 'update' objects in the request body. The fields that can be set are determined by the 'Get create issue metadata' API. When creating a subtask, 'issueType' must be set to a subtask issue type, and 'parent' must contain the ID or key of the parent issue. The API supports adding the project to the user's Recently viewed project list using the 'updateHistory' query parameter. The response includes the ID, key, and URL of the created issue, along with any transition status and error messages if applicable.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Create Issue Type

  • ID: post_create_issue_type
  • Operation: write
  • Entities: issue type, default issue type scheme
  • Summary: This API creates an issue type and adds it to the default issue type scheme. It requires a unique name for the issue type, with an optional description and hierarchy level. The request body must be in JSON format. If successful, it returns a 201 status code with the issue type details. Errors include 400 for invalid requests, 401 for authentication issues, 403 for permission issues, and 409 if the issue type name is already in use.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Create User in Jira

  • ID: post_create_user_in_jira
  • Operation: write
  • Entities: account, product, user
  • Summary: This API creates a user in Jira. It is retained for legacy compatibility and may be deprecated in the future. The API requires the user's email address and the products they should have access to. If the user already exists and has access to Jira, a 201 status is returned. If the user exists but does not have access, a 400 status is returned. The request body must include the email address and products fields. The response includes details about the created user, such as account ID, display name, email address, and avatar URLs.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Get Comments by IDs

  • ID: post_get_comments_by_ids
  • Operation: read
  • Entities: user, role, comment
  • Summary: This API returns a paginated list of comments specified by a list of comment IDs. It can be accessed anonymously, but requires certain permissions such as 'Browse projects' for the project containing the comment, issue-level security permission if configured, and visibility restrictions if applicable. The request accepts a list of comment IDs in the body, with a maximum of 1000 IDs. The 'expand' query parameter can be used to include additional information such as renderedBody and properties. The response includes pagination details and a list of comments with their metadata.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Load Issue Type Avatar

  • ID: post_load_issue_type_avatar
  • Operation: write
  • Entities: issue type, avatar, image
  • Summary: This API loads an avatar for a specified issue type in Jira. The avatar image is uploaded via a POST request to the specified endpoint. The request must include headers for XSRF protection and content type, and the image file is specified in the request body. The image is cropped to a square, and avatars of various sizes are created. The API requires the issue type ID as a path parameter and accepts optional query parameters for cropping. A successful request returns the avatar details in JSON format.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Search for Issues using JQL (POST)

  • ID: post_search_for_issues_using_jql
  • Operation: read
  • Entities: issue, project, user
  • Summary: This API allows users to search for issues using JQL (Jira Query Language) via a POST request. The request body must include a JQL expression and can optionally include parameters such as expand, fields, fieldsByKeys, maxResults, startAt, and validateQuery to customize the search results. The response includes a list of issues matching the JQL query, along with additional information such as issue fields, comments, attachments, and more. The API supports various authentication methods and can be accessed anonymously if the necessary permissions are granted.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Search Issue IDs using JQL

  • ID: post_search_issue_ids_using_jql
  • Operation: read
  • Entities: issue, project, permission
  • Summary: This API endpoint allows users to search for issue IDs using JQL (Jira Query Language). It is accessed via a POST request to '/rest/api/3/search/id'. The request body must include a JQL expression, and optionally, the maximum number of results per page and a continuation token for pagination. The response returns a list of issue IDs and a token for fetching the next page if available. This operation can be accessed anonymously, but requires appropriate project permissions. The API supports basic authentication and OAuth2. If the JQL query is invalid, a 400 error is returned. If authentication fails, a 401 error is returned.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Send Notification for Issue

  • ID: post_send_notification_for_issue
  • Operation: write
  • Entities: issue, email, notification
  • Summary: This API endpoint creates an email notification for a specified issue and adds it to the mail queue. It requires the 'Browse Projects' permission for the project that the issue is in, and if issue-level security is configured, the issue-level security permission to view the issue. The request must include the issue ID or key as a path parameter and a request body detailing the notification content and recipients. The response will indicate success with a 204 status code if the email is queued, or provide error messages for invalid requests, missing issues, or configuration issues.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Transition Issue in Jira

  • ID: post_transition_issue_in_jira
  • Operation: write
  • Entities: issue, field, transition
  • Summary: This API performs a transition on a Jira issue and updates fields if the transition has a screen. It requires the issue ID or key as a path parameter and accepts a JSON body to specify fields, history metadata, transition details, and updates. The API can be accessed anonymously but requires appropriate permissions. A successful request returns a 204 status code, while various error codes indicate issues such as missing transitions, permission errors, or invalid requests.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Archive Issues by ID or Key

  • ID: put_archive_issues_by_id_or_key
  • Operation: write
  • Entities: issue, project, subtask
  • Summary: This API allows admins to archive up to 1000 issues in a single request using issue ID/key. It returns details of the issues archived and any errors encountered. The request requires a list of issue IDs or keys in the request body. The response includes the number of issues successfully archived and details of any errors, such as issues being subtasks, issues in archived or unlicensed projects, or issues not found. The API requires Premium or Enterprise license and cannot be accessed anonymously. Only admins can perform this operation.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Assign Issue to User

  • ID: put_assign_issue_to_user
  • Operation: write
  • Entities: issue, project, user
  • Summary: This API assigns an issue to a user in Jira. It is used when the calling user has the 'Assign issue' permission but not the 'Edit Issues' permission for the project. The API requires the issue ID or key as a path parameter and the account ID of the user as a request body parameter. If the account ID is set to '-1', the issue is assigned to the default assignee for the project. If set to 'null', the issue is unassigned. The operation can be accessed anonymously, but requires 'Browse Projects' and 'Assign Issues' permissions. The API returns a 204 status code if successful, and various error codes if there are issues with the request.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Edit Issue in Jira

  • ID: put_edit_issue_in_jira
  • Operation: write
  • Entities: issue, field, permission
  • Summary: The Edit Issue API allows users to update the properties of an issue in Jira. The API endpoint is /rest/api/3/issue/{issueIdOrKey} and uses the PUT method. Users can update fields using the 'update' and 'fields' objects in the request body. The API supports optional query parameters such as 'notifyUsers', 'overrideScreenSecurity', 'overrideEditableFlag', 'returnIssue', and 'expand'. The request body must include the fields to be updated, and it can also include history metadata and properties. The response varies based on the success of the request and the 'returnIssue' parameter. The API requires appropriate permissions to edit issues and can be accessed anonymously if the necessary permissions are granted.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Export Archived Issues

  • ID: put_export_archived_issues
  • Operation: read
  • Entities: issue, reporter, project
  • Summary: This API allows administrators to export details of archived issues in Jira. The request can be filtered by projects, archivedBy, archivedDate, issueTypes, and reporters. All filters are optional, and if none are provided, up to one million archived issues will be exported. The response includes the status of the export task, and upon successful request, an email with a download link for a CSV file containing the issue details will be sent to the admin. The API requires Premium or Enterprise license and cannot be accessed anonymously. It supports basic authentication and OAuth2. Rate limiting allows only one active request at a time.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Set User Default Columns

  • ID: put_set_user_default_columns
  • Operation: write
  • Entities: column, user, issue table
  • Summary: This API sets the default issue table columns for a user in Jira. If an account ID is not provided, the default columns for the calling user are set. If no column details are sent, all default columns are removed. The request requires the 'Administer Jira' global permission to set columns for any user, or permission to access Jira to set the calling user's columns. The request parameters include an optional 'accountId' query parameter to specify the user and a required 'columns' array in the request body to specify the columns to set. The response will be successful if the request is valid, otherwise, it may return errors such as authentication failure, permission issues, user not found, rate limit exceeded, or invalid column ID.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Set User Property

  • ID: put_set_user_property
  • Operation: write
  • Entities: user, property
  • Summary: The Set User Property API allows you to set the value of a user's property in Jira. This API requires the 'Administer Jira' global permission to set a property on any user, or access to Jira to set a property on the calling user's record. The API endpoint is '/rest/api/3/user/properties/{propertyKey}', where 'propertyKey' is a required path parameter representing the key of the user's property. The request must include the 'accountId' query parameter, which uniquely identifies the user. The request body must contain a valid JSON value representing the property value. The API returns a 200 status code if the user property is updated, a 201 status code if created, and various error codes for missing parameters or permissions.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Unarchive Issues by Issue Keys/ID

  • ID: put_unarchive_issues_by_issue_keys_id
  • Operation: write
  • Entities: issue, project, subtask
  • Summary: This API allows administrators to unarchive up to 1000 issues in a single request using issue IDs or keys. It returns details of the issues unarchived and any errors encountered during the process. Note that subtasks cannot be unarchived directly and must be done through their parent issues. The API is applicable only for issues from software, service management, and business projects. It requires a Premium or Enterprise license and cannot be accessed anonymously. The request body must include a list of issue keys or IDs to be unarchived. The response will include the count of unarchived issues and detailed errors for issues that could not be unarchived. Possible error responses include 400 for bad requests, 401 for unauthorized access, 403 for forbidden access, and 412 if the number of issues exceeds the limit.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Update Comment on Jira Issue

  • ID: put_update_comment_on_jira_issue
  • Operation: write
  • Entities: issue, user, comment
  • Summary: This API updates a comment on a Jira issue. It requires the issue ID or key and the comment ID as path parameters. Optional query parameters include notifyUsers, overrideEditableFlag, and expand. The request body must include the comment content and visibility settings. The response includes details about the updated comment, such as the author, content, creation and update timestamps, and visibility restrictions. The operation can be accessed anonymously, but permissions are required to edit comments.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Update Issue Type

  • ID: put_update_issue_type
  • Operation: write
  • Entities: issue type, avatar
  • Summary: The Update Issue Type API allows you to update the details of an existing issue type in Jira. The API requires the issue type ID as a path parameter. The request body can include the avatar ID, description, and name of the issue type. The name must be unique and not exceed 60 characters. The API returns a 200 status code if successful, with the updated issue type details. Errors may occur if the request is invalid, authentication fails, permissions are insufficient, the issue type is not found, or the name is already in use.
  • Input Fields: Input Fields
  • Output Fields: Output Fields

Updated 4 days ago