This QuickStart demonstrates integrating JIRA's REST API with Sigma using Basic Authentication and API Actions. You'll connect to JIRA Cloud, query issues using JQL (JIRA Query Language), and optionally update issue statuses directly from Sigma workbooks.

Unlike simple no-authentication examples, this QuickStart shows enterprise-grade patterns using authenticated API requests with dynamic parameters.

What you'll build:

A Sigma workbook that:

Along the way you'll learn how to:

For more information on Sigma's product release strategy, see Sigma product releases

If something doesn't work as expected, here's how to contact Sigma support

Target Audience

This QuickStart is ideal for:

Prerequisites

Sigma Free Trial

Footer

Assuming you have already created a JIRA trial account, perform the following steps:

  1. Browse to: JIRA API Tokens creation page
  2. Click Create API token:

  1. Name it: QuickStarts Token and give it a date in the future that allows enough time to complete testing:

  1. Click Create
  2. Copy the token immediately - you won't see it again! (place it in a safe location):

  1. Click Done.

Footer

JIRA Cloud uses Basic Authentication with API tokens. This is simpler than OAuth 2.0 and works well for server-to-server integrations like Sigma.

How Basic Auth works:

Why this approach:

Sigma API Actions support many common authentication methods including (at the time of this QuickStart):

For more information, see Add a new API credential to Sigma

Footer

Now we'll create a credential in Sigma that securely stores your JIRA authentication details.

  1. In Sigma, navigate to Administration > API connectors > Credentials
  2. Click Create Credential:

  1. Configure the credential:
    • Name: JIRA API Token
    • Description: Basic Auth for JIRA Cloud API
    • Authorized domains: Your specific JIRA domain (e.g., yourcompany.atlassian.net)
    • Authentication method: Basic auth
    • Username: Your JIRA email address (e.g., yourname@domain.com)
    • Password: Paste the API token you created in the previous section (the API token serves as the password for Basic auth)

  1. Click Save.

The credential is now available for use in API connectors throughout your Sigma organization.

Footer

API connectors define the endpoints we'll call from Sigma. First, let's create a connector that searches for JIRA issues using JQL.

Create the Connector

  1. Still on the Administration > API Connectors page, select the API connectors tab.
  2. Click Create connector
  3. Configure the connector details:
    • Name: JIRA - Search Issues
    • Description: Query JIRA issues using JQL
    • Credential: Select JIRA API Token (the credential we created)
  4. In the Request details section, configure:
    • Connector type: Custom connector
    • Base URL: Set the method to GET and enter https://YOUR-DOMAIN.atlassian.net/rest/api/3/search/jql (replace YOUR-DOMAIN with your actual JIRA domain)

Add Query Parameters

  1. In the Query parameters section, click Add parameter:
    • Key: jql
    • Mode: Static
    • Value: project = SCRUM ORDER BY created DESC

This default JQL query retrieves all issues from the SCRUM project, ordered by creation date.

  1. Add a second query parameter for the fields we want to retrieve:
    • Key: fields
    • Mode: Static
    • Value: key,summary,status,priority,assignee,created,issuetype

This tells JIRA which fields to return in the response. Without this parameter, the API returns minimal data (only IDs).

  1. Optionally add a third query parameter to limit results:
    • Key: maxResults
    • Mode: Static
    • Value: 50

This limits the number of results returned (JIRA's default is 50, maximum is 100).

  1. Click Test connector to verify the connector works.

You should see a successful response with JIRA issue data in JSON format, now including all the fields (key, summary, status, etc.):

  1. Click Save to save the API connector

Footer

Before we build the Sigma workbook, let's create some sample issues in JIRA to work with. A JIRA trial starts with empty projects, so we need to add test data.

Navigate to Your Project

  1. Go to your JIRA board: https://YOUR-DOMAIN.atlassian.net/jira/software/projects/SCRUM/boards/1
  2. You should see a Scrum board with columns: To Do, In Progress, In Review, Done.

JIRA may have created a couple of default tasks (Task 1, Task 2) to get you started. You can keep these or delete them to make the UI cleaner.

Create Issues

  1. Click the + Create button at the top of the page:

  1. Select Task for Work type.
  2. For the Summary field, use Set up development environment
  3. Click Create.

A popup will appear that allows us to assign the new task to our default scrum and sprint. Click the Add to SCRUM Sprint 0 link:

The issue will appear in the TO DO column:

  1. Create additional issues with variety using different work types (Task, Story, Epic). Here's a suggested set organized by status:

TO DO:

IN PROGRESS:

IN REVIEW:

DONE:

The following optional sections are provided to orient readers less familiar with JIRA and are not required.

Set Different Statuses (optional)

  1. To change an issue's status, drag and drop it between columns on the board:
    • Drag some issues to In Progress
    • Drag some to In Review
    • Drag some to Done

Add Details (Optional)

  1. For more realistic data, click on individual issues and add:
    • Priority: High, Medium, or Low
    • Assignee: Assign some to yourself, leave others unassigned
    • Labels: Add tags like "backend", "frontend", "urgent"
    • Due dates: Add dates to a few issues

Verify Your Data (Optional)

  1. Once you've created several issues, test the JQL query in JIRA:

Alternatively, you can verify by simply viewing your board - all the issues you created should be visible in their respective columns.

Now you're ready to query this data from Sigma!

Footer

Before building the workbook, let's understand how we'll parse JIRA's JSON responses using Python. We're covering this now so you understand the overall data flow before implementing it in the next section. This preview will make the workbook setup clearer and help you understand why each element is needed.

Why Python elements:

JIRA's API returns nested JSON with arrays of issues, each containing multiple fields. Python elements (which run on Snowflake) let us transform this JSON into tabular data that Sigma can display and analyze.

How the workflow works:

  1. Button action calls API → stores JSON response in a text area control
  2. Python element reads from text area → using sigma.get_control_value()
  3. Python parses and flattens JSON → extracts fields from nested structure
  4. Python outputs DataFrame → using sigma.output() to make it available to child elements
  5. Child table element displays data → shows the parsed issues in table format

What the Python code does:

import pandas as pd
import json

# Read the API response from the text area control
raw = sigma.get_control_value("raw-response")

# Parse the JSON response
response_data = json.loads(raw)

# Extract issues array
issues = response_data.get('issues', [])

# Flatten nested JSON into tabular format
flattened_issues = []

for issue in issues:
    flattened_issues.append({
        'Issue Key': issue['key'],
        'Summary': issue['fields']['summary'],
        'Status': issue['fields']['status']['name'],
        'Priority': issue['fields']['priority']['name'] if issue['fields'].get('priority') else 'None',
        'Assignee': issue['fields']['assignee']['displayName'] if issue['fields'].get('assignee') else 'Unassigned',
        'Created': issue['fields']['created'],
        'Work Type': issue['fields']['issuetype']['name']
    })

# Convert to DataFrame
df = pd.DataFrame(flattened_issues)

# Output the DataFrame so child elements can use it
sigma.output("jira_issues", df)

This code extracts key fields from each nested issue object and creates a DataFrame with one row per issue.

For more information, see Write and run Python code in Sigma

Footer

Now let's create a workbook that calls the JIRA API and displays the results.

Create a New Workbook

  1. In Sigma, click Create New > Workbook
  2. Click Save as and name the workbook JIRA Issues QuickStart in your preferred location
  3. Rename the first page from Page 1 to Issues

Add a Text Area for Raw Response

  1. From the Element bar, add a Text area control from the Controls group
  2. Configure the text area:
    • Control ID: raw-response
    • Placeholder (found in the Format > ELEMENT STYLE tab): API response will appear here

This control will display the raw JSON response for debugging purposes.

Add a Button to Trigger the API Call

  1. Add a Button element from the UI group
  2. Change the button text to Load JIRA Issues

Configure Button Actions

  1. Click on the button and select Action sequence from the Element properties panel

We'll create a sequence of three actions for now:

Action 1: Clear the Raw Response

Action 2: Call the JIRA API

The Outputs section shows the action variables:

Action 3: Display the Raw Response

Test the API Call

  1. Click the Load JIRA Issues button

You should see the raw JSON response appear in the text area control, showing your JIRA issues.

Footer

Now we'll use a Python element to transform the JSON response into a table.

Add a Python Element

  1. From the Element bar, add a Python element from the Data group
  2. Select the Snowflake connection that has Python enabled.

For more information, see Write and run Python code in Sigma

Write the Python Code

  1. In the Python editor, replace all the sample code in the element with:
import pandas as pd
import json

# Read the API response from the text area control
raw = sigma.get_control_value("raw-response")

# Handle empty response - create empty DataFrame with proper schema
if not raw:
    df = pd.DataFrame({
        "Issue Key": pd.Series(dtype="str"),
        "Summary": pd.Series(dtype="str"),
        "Status": pd.Series(dtype="str"),
        "Priority": pd.Series(dtype="str"),
        "Assignee": pd.Series(dtype="str"),
        "Created": pd.Series(dtype="str"),
        "Work Type": pd.Series(dtype="str")
    })
else:
    # Parse the JSON response
    response_data = json.loads(raw)

    # Extract issues array
    issues = response_data.get('issues', [])

    # Flatten nested JSON into tabular format
    flattened_issues = []

    for issue in issues:
        flattened_issues.append({
            'Issue Key': issue['key'],
            'Summary': issue['fields']['summary'],
            'Status': issue['fields']['status']['name'],
            'Priority': issue['fields']['priority']['name'] if issue['fields'].get('priority') else 'None',
            'Assignee': issue['fields']['assignee']['displayName'] if issue['fields'].get('assignee') else 'Unassigned',
            'Created': issue['fields']['created'],
            'Work Type': issue['fields']['issuetype']['name']
        })

    # Convert to DataFrame
    df = pd.DataFrame(flattened_issues)

# Output the DataFrame as 'jira_issues' for child elements
sigma.output("jira_issues", df)
  1. Click Run to execute the Python code

You should see an output option appear:

Add Child Table Element

  1. Select the jira_issues control and click Table from the menu:

A table will appear showing all the parsed JIRA issues with properly formatted columns. We moved the elements around in the screenshot below...

  1. Rename the table to JIRA Issues Table

Update Button to Refresh Python Element

  1. Now that the Python element exists, go back to the Load JIRA Issues button and add a fourth action:

Click on the button and select Edit actions

Action 4: Run the Python Element

This triggers the Python element to re-execute and parse the updated API response.

Test the Complete Workflow

  1. Click the Load JIRA Issues button

You should now see:

The complete workflow now refreshes both the raw response and the parsed table automatically!

Footer

Let's add a control that lets users filter issues by status.

Add a Status Filter Control

  1. Add a List values control from the Controls group
  2. Configure it:
    • Control ID: status-filter
    • Allow multiple selection: Disabled (unchecked)

This separates what users see (clean text without quotes) from what gets used in formulas (values with quotes for JQL).

Create a Second API Connector for Filtered Queries

Following the pattern from the Salesforce QuickStart, we'll create a second API connector specifically for filtered queries. This keeps the button working unchanged.

  1. Navigate to Administration > API Connectors
  2. Find the JIRA - Search Issues connector and click the three-dot menu
  3. Select Duplicate:

  1. Open the copied connector and rename it JIRA - Search Issues by Status
  2. Set the Authentication credential to JIRA API Token.
  3. In the Query parameters section, find the jql parameter
  4. Change Mode from Static to Dynamic

Dynamic parameters don't have default values:

  1. Click Save

Now we have two connectors:

Add Action to the Status Filter Control

Now we'll configure the status filter control to automatically refresh the data when a user selects a different status.

  1. Go back to your workbook
  2. Click on the Status Filter control
  3. In the Element properties panel, go to the Actions tab

We'll create a sequence similar to the button, but using the new dynamic connector:

Action 1: Clear the Raw Response

Action 2: Call the JIRA API with Dynamic JQL

In the parameter mapping section:

If([status-filter] = "All", "project = SCRUM ORDER BY created DESC", "project = SCRUM AND status = " & [status-filter] & " ORDER BY created DESC")

This formula:

The quotes are already part of the control value, so they're automatically included in the JQL query.

Action 3: Set the Raw Response

Action 4: Run the Python Element

Test the Filter

Try selecting different statuses from the Status Filter control.

The the Python will run, raw-response will update and the table will update to show only issues matching the selected status - no need to click the button.

Footer

Want to update JIRA issues directly from Sigma? Let's add a write-back workflow using JIRA's transitions API.

Find Available Transitions

Before creating the transition connector, we need to discover the transition IDs for your workflow. Let's create a connector in Sigma to find them.

  1. Navigate to Administration > API Connectors
  2. Click Create connector
  3. Configure the connector:
    • Name: JIRA - Get Transitions
    • Description: Get available transitions for an issue
    • Credential: JIRA API Token
  4. Configure the request details:
    • Connector type: Custom connector
    • Base URL: Set method to GET and enter https://YOUR-DOMAIN.atlassian.net/rest/api/3/issue/:issueKey/transitions

Replace YOUR-DOMAIN with your actual JIRA domain. The /:issueKey syntax tells Sigma this is a path parameter.

  1. Scroll down to the Path parameters section and configure:
    • Key: issueKey (matches the parameter name in the base URL)
    • Mode: Static
    • Value: Enter one of your test issue keys (e.g., SCRUM-1)

The /:issueKey in the base URL will be replaced with this value when the connector is called.

  1. Click Test connector

The response shows available transitions for that issue:

{
  "transitions": [
    {
      "id": "11",
      "name": "To Do",
      "to": { "id": "10000", "name": "To Do" }
    },
    {
      "id": "21",
      "name": "In Progress",
      "to": { "id": "10001", "name": "In Progress" }
    },
    {
      "id": "31",
      "name": "In Review",
      "to": { "id": "10002", "name": "In Review" }
    },
    {
      "id": "41",
      "name": "Done",
      "to": { "id": "10003", "name": "Done" }
    }
  ]
}
  1. Note the transition IDs from the response:
    • "11" = To Do
    • "21" = In Progress
    • "31" = In Review
    • "41" = Done

These are the IDs you'll use in the next connector. Yours will likely be different.

  1. You can save or discard this connector—it was just for discovery

Create a Dynamic Transition Connector

  1. Navigate to Administration > API Connectors.
  2. Create a new API connector:
    • Name: JIRA - Transition Issue
    • Description: Transition JIRA issue to a new status
    • Credential: JIRA API Token
  3. Configure the connector details:
    • Connector type: Custom connector
    • Base URL:
      • Important: Change the method dropdown from GET to POST
      • Enter: https://YOUR-DOMAIN.atlassian.net/rest/api/3/issue/:issueKey/transitions

Replace YOUR-DOMAIN with your actual JIRA domain. The /:issueKey syntax tells Sigma this is a path parameter.

  1. In the Path parameters section, configure:
    • Key: issueKey (matches the parameter name in the base URL)
    • Mode: Dynamic

The /:issueKey in the base URL will be dynamically replaced with values from your workbook, so set it to be Dynamic under Path parameters.

  1. Scroll down to the Request body section:
    • Select the raw radio button (not "none" or "form-data")
    • In the text area that appears, enter this JSON template:
{
  "transition": {
    "id": {{transitionId}}
  }
}

The {{transitionId}} is a placeholder that will be replaced by the parameter value.

  1. Scroll down to the Body parameters section. Sigma automatically detects the transitionId parameter from your JSON template. Configure it:
    • Key: transitionId (automatically added)
    • Type: Number (transition IDs are numeric)

  1. Test the connector:
    • issueKey: Enter a test issue key (e.g., SCRUM-10)
    • transitionId: Enter a valid transition ID from step 7 (e.g., 21 for "In Progress")
  2. Click Test connector to verify it works:

You can also check to make sure JIRA shows the change (moved SCRUM-10 from TO DO to IN-PROGRESS)

Add Status Update Modal to Workbook

Now let's create an interactive modal that allows users to update issue statuses.

Create the Modal and Controls

  1. In your workbook, add a UI > Modal element
  2. Rename the modal to Update Status Modal
  3. Add a Text input control:

This control will display which issue is being updated.

  1. Add a List values control.

Toggle on Set display values.

We will use the Primary button to initiate actions when clicked but first we need to configure actions on the table.

Add Action to Status Column

  1. Back on the JIRA Issues Table, click on the Status column header
  2. In the Element properties panel, go to the Actions tab
  3. Add an action with trigger On click > Status.

Action 1: Set Issue Key

Action 2: Open Modal

Now when users click a Status cell, the modal opens with the Modal Issue Key pre-filled:

Configure Save Button Actions

  1. Back on Modal 1, add the following action sequence to the On click - primary action sequence.

Action 1: Call Transition API

Number([modal-new-status])

Action 2: Reload JIRA Data

This re-fetches all issues from JIRA after the transition, ensuring you see the updated status regardless of what filter is currently selected:

Action 3: Set Raw Response

Action 4: Run Python Element

This parses the fresh data and updates the table.

Action 5: Clear Status Selection

This resets the dropdown so the next time the modal opens, no status is pre-selected.

Action 6: Close Modal

Click Save to save the complete action sequence.

Test the Workflow

Let's move the Set up development environment task that we moved into IN PROGRESS manually a few steps back to TO DO:

  1. Click on the Status cell for the issue
  2. The modal should open with the Issue Key displayed
  3. Select a new status from the dropdown (e.g., "To Do")

  1. Click Save.

The API call will execute, the modal will close, and the table should refresh to show the updated status:

Now users can transition issue statuses directly from Sigma, and the table will automatically refresh to show the changes!

Footer

In about an hour, you built a complete bidirectional JIRA integration—querying issues with dynamic filters, parsing nested JSON responses, and updating issue statuses through an interactive modal—all without writing backend code or managing servers.

Sigma API Actions turned what would typically require dedicated API infrastructure, authentication handling, and custom middleware into a straightforward workflow: configure credentials, define connectors, build actions.

This same pattern works for any REST API using Basic Authentication (ServiceNow, Zendesk, GitHub, GitLab, Confluence, Bitbucket). Create credentials, define endpoints, call APIs, parse responses, display results.

The value isn't just speed—it's accessibility. Business analysts and data teams can now build operational integrations that previously required engineering resources, turning Sigma into a true operational analytics platform where data doesn't just flow in for reporting, but flows back out to drive action.

Additional Resource Links

Blog
Community
Help Center
QuickStarts

Be sure to check out all the latest developments at Sigma's First Friday Feature page!

   

Footer