# Work with Jira Issues

> For the complete documentation index, see [llms.txt](https://docs.redpanda.com/llms.txt). Component-specific: [cloud-data-platform-full.txt](https://docs.redpanda.com/cloud-data-platform-full.txt)

---
title: Work with Jira Issues
latest-operator-version: v26.1.4
latest-console-tag: v3.7.3
latest-connect-version: 4.93.0
latest-redpanda-tag: v26.1.9
docname: connect/cookbooks/jira
page-component-name: cloud-data-platform
page-version: master
page-component-version: master
page-component-title: Cloud
page-relative-src-path: connect/cookbooks/jira.adoc
page-edit-url: https://github.com/redpanda-data/cloud-docs/edit/main/modules/develop/pages/connect/cookbooks/jira.adoc
description: Learn how to query, filter, and create Jira issues using Redpanda Connect pipelines.
page-topic-type: cookbook
personas: streaming_developer, data_engineer
learning-objective-1: Query Jira issues using JQL patterns with the Jira processor
learning-objective-2: Combine generate input with Jira processor for scheduled queries
learning-objective-3: Create Jira issues using the HTTP processor and REST API
page-git-created-date: "2026-02-18"
page-git-modified-date: "2026-02-18"
---

<!-- Source: https://docs.redpanda.com/cloud-data-platform/develop/connect/cookbooks/jira.md -->

The Jira processor enables querying Jira issues using JQL (Jira Query Language) and returning structured data. It’s a processor, so you can use it in pipelines for input-style flows (pair with `generate`) or output-style flows (pair with `drop`).

Use this cookbook to:

-   Query Jira issues on a schedule or on-demand

-   Filter issues using JQL patterns

-   Create Jira issues using the HTTP processor


## [](#prerequisites)Prerequisites

The examples in this cookbook use the Secrets Store for Jira credentials. This keeps sensitive credentials secure and separate from your pipeline configuration.

1.  [Generate a Jira API token](https://id.atlassian.com/manage-profile/security/api-tokens).

2.  Add your Jira credentials to the [Secrets Store](https://docs.redpanda.com/cloud-data-platform/develop/connect/configuration/secret-management/):

    -   `JIRA_BASE_URL`: Your Jira instance URL (for example, `https://your-domain.atlassian.net`)

    -   `JIRA_USERNAME`: Your Jira account email address

    -   `JIRA_API_TOKEN`: The API token generated from your Atlassian account

    -   `JIRA_AUTH_TOKEN` (optional, for creating issues): Base64-encoded `username:api_token` string



## [](#use-jira-as-an-input)Use Jira as an input

To use Jira as an input, combine the `generate` input with the Jira processor. This pattern triggers Jira queries at regular intervals or on-demand.

> 💡 **TIP**
>
> Replace `MYPROJECT` in the examples with your actual Jira project key.

### [](#query-jira-periodically)Query Jira periodically

This example queries Jira every 30 seconds for recent issues:

```yaml
input:
  generate:
    interval: 30s
    mapping: |
      root.jql = "project = MYPROJECT AND updated >= -1h ORDER BY updated DESC"
      root.maxResults = 50
      root.fields = ["key", "summary", "status", "assignee", "priority"]

pipeline:
  processors:
    - jira:
        base_url: "${secrets.JIRA_BASE_URL}"
        username: "${secrets.JIRA_USERNAME}"
        api_token: "${secrets.JIRA_API_TOKEN}"

output:
  stdout: {}
```

### [](#one-time-query)One-time query

For a single query, use `count` instead of `interval`:

```yaml
input:
  generate:
    count: 1
    mapping: |
      root.jql = "project = MYPROJECT AND status = Open"
      root.maxResults = 100

pipeline:
  processors:
    - jira:
        base_url: "${secrets.JIRA_BASE_URL}"
        username: "${secrets.JIRA_USERNAME}"
        api_token: "${secrets.JIRA_API_TOKEN}"

output:
  stdout: {}
```

## [](#input-message-format)Input message format

The Jira processor expects input messages containing valid Jira queries in JSON format:

```json
{
  "jql": "project = MYPROJECT AND status = Open",
  "maxResults": 50,
  "fields": ["key", "summary", "status", "assignee"]
}
```

### [](#required-fields)Required fields

-   `jql`: The JQL (Jira Query Language) query string


### [](#optional-fields)Optional fields

-   `maxResults`: Maximum number of results to return (default: 50)

-   `fields`: Array of field names to include in the response


## [](#jql-query-patterns)JQL query patterns

Here are common JQL patterns for filtering issues:

### [](#recent-issues-by-project)Recent issues by project

```jql
project = <YOUR_PROJECT> AND created >= -7d ORDER BY created DESC
```

### [](#issues-assigned-to-current-user)Issues assigned to current user

```jql
assignee = currentUser() AND status != Done
```

### [](#issues-by-status)Issues by status

```jql
project = <YOUR_PROJECT> AND status IN (Open, 'In Progress', 'To Do')
```

### [](#issues-by-priority)Issues by priority

```jql
project = <YOUR_PROJECT> AND priority = High ORDER BY created DESC
```

## [](#output-message-format)Output message format

The Jira processor returns individual issue messages, rather than a response object with an `issues` array.

Each message output by the Jira processor represents a single issue:

```json
{
  "id": "12345",
  "key": "DOC-123",
  "fields": {
    "summary": "Example issue",
    "status": {
      "name": "In Progress"
    },
    "assignee": {
      "displayName": "John Doe"
    }
  }
}
```

The Jira processor automatically handles pagination internally. The processor:

1.  Makes the initial request with `startAt=0`.

2.  Checks if more results are available.

3.  Automatically fetches subsequent pages until all results are retrieved.

4.  Outputs each issue as an individual message.


You don’t need to handle pagination manually.

## [](#create-and-update-jira-issues)Create and update Jira issues

The Jira processor is read-only and only supports querying. To create or update Jira issues, use the [`http` processor](https://docs.redpanda.com/cloud-data-platform/develop/connect/components/processors/http/) with the Jira REST API.

### [](#create-a-jira-issue)Create a Jira issue

```yaml
input:
  generate:
    count: 1
    mapping: |
      root.fields = {
        "project": {"key": "MYPROJECT"},
        "summary": "Issue created from Redpanda Connect",
        "description": {
          "type": "doc",
          "version": 1,
          "content": [{"type": "paragraph", "content": [{"type": "text", "text": "Created via API"}]}]
        },
        "issuetype": {"name": "Task"}
      }

pipeline:
  processors:
    - http:
        url: "${secrets.JIRA_BASE_URL}/rest/api/3/issue"
        verb: POST
        headers:
          Content-Type: application/json
          Authorization: "Basic ${secrets.JIRA_AUTH_TOKEN}"

output:
  stdout: {}
```

## [](#see-also)See also

-   [Jira processor reference](https://docs.redpanda.com/cloud-data-platform/develop/connect/components/processors/jira/)

-   [Jira REST API documentation](https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/)

-   [JQL query guide](https://www.atlassian.com/software/jira/guides/jql)