JIRA

Open your browser and go to id.atlassian.com/manage-profile/security/api-tokens. Click 'Create API token', give it a label like 'Bubble Integration', and click Create. Copy the token value immediately — it is only shown once. Now you need to create the Basic Auth string. Jira uses HTTP Basic Auth where the username is your Atlassian account email and the password is the API token. Concatenate them with a colon: youremail@company.com:your_api_token_here. Then Base64-encode this entire string. You can do this at base64encode.org — paste the email:token string into the encoder and copy the resulting Base64 string. The final Authorization header value will be: Basic YOUR_BASE64_STRING (the word 'Basic' followed by a space, then the encoded string). Store this complete header value somewhere safe — you will paste it into Bubble's API Connector in the next step.

1Step-by-step auth string construction:
2
31. Your email: youremail@company.com
42. Your API token: your_api_token_here
53. Concatenate: youremail@company.com:your_api_token_here
64. Base64-encode the result: eW91cmVtYWlsQGNvbXBhbnkuY29tOnlvdXJfYXBpX3Rva2VuX2hlcmU=
75. Final header value: Basic eW91cmVtYWlsQGNvbXBhbnkuY29tOnlvdXJfYXBpX3Rva2VuX2hlcmU=

In Bubble, go to Plugins → API Connector → click 'Add another API'. Name the group 'Jira API'. The Jira Cloud API base URL is specific to your organization's subdomain. In the API base URL field, enter: https://YOUR-DOMAIN.atlassian.net/rest/api/3 — replace YOUR-DOMAIN with your actual Jira subdomain. This is important: every user's Jira instance is at a different subdomain, so the URL is not generic. Under 'Shared headers for all calls', add one header: key = Authorization, value = Basic YOUR_BASE64_STRING (paste the full value from Step 1). Check the Private checkbox on this header — this keeps the Base64-encoded credentials off the client side. Also add a Content-Type header: key = Content-Type, value = application/json (this is needed for POST calls). Leave Content-Type as non-Private (it is not a secret). You now have two shared headers: Authorization (Private) and Content-Type.

1API Connector Group: Jira API
2  Base URL: https://YOUR-DOMAIN.atlassian.net/rest/api/3
3
4  Shared headers:
5  - Authorization: Basic <base64(email:token)>  [Private: YES]
6  - Content-Type: application/json              [Private: NO]

In the Jira API group, click 'Add another call'. Name it 'Search Issues'. Set Method to POST and URL to /search (the full URL will be your base URL + /search = https://YOUR-DOMAIN.atlassian.net/rest/api/3/search). Set 'Use as' to 'Data' so Bubble treats this as a data source for display elements. In the Body, check 'Send arbitrary data' and provide a JSON body with a JQL query string and the fields you want returned. JQL (Jira Query Language) is a SQL-like syntax for filtering issues. A basic example: query all open issues in a project ordered by creation date. Click 'Initialize call' — Bubble will send the request to Jira and parse the schema. After initialization, Bubble detects the 'issues' array with nested fields like issues[0].key, issues[0].fields.summary, issues[0].fields.status.name, and issues[0].fields.assignee.displayName. You can bind these to a Repeating Group's data source.

1POST /search
2
3Body:
4{
5  "jql": "project = YOUR_PROJECT_KEY AND status != Done ORDER BY created DESC",
6  "maxResults": 50,
7  "fields": [
8    "summary",
9    "status",
10    "priority",
11    "assignee",
12    "created",
13    "issuetype"
14  ]
15}

In the Jira API group, click 'Add another call'. Name it 'Create Issue'. Set Method to POST and URL to /issue. Set 'Use as' to 'Action' since this is triggered from a workflow. In the Body, check 'Send arbitrary data'. The most critical part of this call is the description field structure — Jira Cloud v3 does NOT accept a plain string. It requires Atlassian Document Format (ADF): a JSON tree with a doc node containing content blocks. Sending 'description': 'my bug description' returns HTTP 400 Bad Request immediately. Use the ADF structure shown in the code example below. Define dynamic parameters for summary (<issue_summary>), description content (<issue_description>), and project key (configure as a static value matching your project). Initialize the call with real example values to confirm the structure. After initialization, Bubble confirms the call works and detects the returned issue id and key.

1POST /issue
2
3Body:
4{
5  "fields": {
6    "project": {
7      "key": "YOUR_PROJECT_KEY"
8    },
9    "summary": "<dynamic: issue_summary>",
10    "issuetype": {
11      "name": "Bug"
12    },
13    "priority": {
14      "name": "Medium"
15    },
16    "description": {
17      "type": "doc",
18      "version": 1,
19      "content": [
20        {
21          "type": "paragraph",
22          "content": [
23            {
24              "type": "text",
25              "text": "<dynamic: issue_description>"
26            }
27          ]
28        }
29      ]
30    }
31  }
32}

Now connect the Jira API calls to your Bubble UI. Add a form to your Bubble page with input elements for Issue Summary (single-line text input) and Description (multiline text input). Add a 'Submit' button. In the button's workflow: Step 1 — add a Plugin action 'Jira API — Create Issue'. Map the issue_summary parameter to the Summary input's value, and issue_description to the Description input's value. Step 2 (optional) — Make changes to a Thing: create a record in your Bubble database to store the returned issue key (from Step 1's result's 'key' field), the user who submitted it, and the submission timestamp. Step 3 (optional) — Show an element (e.g., a success popup) that displays 'Your ticket was created: ' + Step 1's result's key. For apps that need the Create Issue call to run server-side (e.g., to prevent token exposure in browser DevTools for public-facing apps), move this to a Backend Workflow — which requires a paid Bubble plan. Note: if you see 'This action will not run' in Bubble's workflow debugger, check that all required parameters have values and are not empty.

1Bubble Workflow: Button 'Submit Bug Report' is clicked
2
3Step 1: [API Action] Jira API - Create Issue
4  → issue_summary: Input Summary's value
5  → issue_description: Input Description's value
6
7Step 2: Create a new Thing (Bug Report)
8  → jira_key: Result of Step 1's key
9  → submitted_by: Current User
10  → submitted_at: Current date/time
11  → summary: Input Summary's value
12
13Step 3: Show element (Popup 'Success')
14Step 4: Reset inputs

To allow Bubble workflows to move Jira issues between statuses (e.g., from 'To Do' to 'In Progress' or 'Done'), you need a two-step process. First, fetch the available transitions for an issue: add a GET call to /issue/{issue_key}/transitions — set 'Use as' to 'Data' and configure issue_key as a dynamic parameter. Initialize with a real issue key to detect the transitions array with id and name fields. Second, apply a transition: add a POST call to /issue/{issue_key}/transitions with a body of {"transition": {"id": "<transition_id>"}}. To use this in a Bubble workflow: Step 1 — call Get Transitions passing the issue key, Step 2 — call the POST transitions endpoint with the id from Step 1's result that matches the target status name. Transition IDs differ between Jira projects and workflow configurations — they are not universal numbers. RapidDev's team has configured Jira status transitions in Bubble for dozens of custom portals — reach out at rapidevelopers.com/contact for help with complex workflow configurations.

1Step A: GET /issue/<issue_key>/transitions
2Returns:
3{
4  "transitions": [
5    { "id": "11", "name": "To Do" },
6    { "id": "21", "name": "In Progress" },
7    { "id": "31", "name": "Done" }
8  ]
9}
10
11Step B: POST /issue/<issue_key>/transitions
12Body:
13{
14  "transition": {
15    "id": "21"
16  }
17}