JIRA

Go to id.atlassian.com/manage-profile/security/api-tokens in your browser. Click Create API token, give it a descriptive label (e.g., 'FlutterFlow integration'), and click Create. Copy the token immediately — Atlassian only shows it once. If you lose it, you'll need to revoke it and generate a new one. The token serves as the password in HTTP Basic authentication. Your username is your full Atlassian account email address. This is different from Jira Server/Data Center which uses a username field — in Jira Cloud, it's always your email. Do not confuse the API token with your Jira login password. They are separate credentials. The API token is safe to use in read-only API calls (stored in App Constants), but you should still treat it carefully because it has the same permissions as your account — it can read and write any project you can access. Also note your Jira Cloud subdomain. If your Jira URL is yourcompany.atlassian.net, your subdomain is yourcompany. You'll need this to build the base URL in the next step.

In FlutterFlow, click the Settings icon in the left sidebar → App Values (App Constants). You'll create two constants: First constant: JIRA_AUTH. This is the Base64-encoded Basic auth header value. Compute it by Base64-encoding the string youremail@company.com:your_api_token (your Atlassian email, a colon, then your API token). Use any online Base64 encoder. The App Constant value should be: Basic [your base64 result] — include the word 'Basic' and a space before the encoded string. Second constant: JIRA_DOMAIN. Set this to your Jira subdomain only (e.g., yourcompany, without .atlassian.net). You'll use this when constructing the base URL so that switching between staging and production Jira instances is as simple as changing one constant. By storing these as App Constants (rather than typing them directly in API Call headers), you make the integration easier to maintain. If you need to rotate the API token, you update the JIRA_AUTH constant once and all API calls pick up the new value without any configuration changes.

1// App Constants to create in FlutterFlow → Settings → App Values
2// JIRA_AUTH:   "Basic [Base64(email:api_token)]"
3//              Example: "Basic amlyYUB5b3VyY29tcGFueS5jb206eW91cl9hcGlfdG9rZW4="
4// JIRA_DOMAIN: "yourcompany"
5//              (just the subdomain, no .atlassian.net)

Click API Calls in the left navigation sidebar of FlutterFlow. Click + Add → Create API Group. Name the group Jira. Set the Base URL to https://{{JIRA_DOMAIN}}.atlassian.net/rest/api/3. This uses your App Constant to make the domain configurable — but note that FlutterFlow App Constants in Base URLs may need to be entered as a static string rather than a variable placeholder in some FlutterFlow versions. If the {{JIRA_DOMAIN}} substitution doesn't work in the base URL, type the full URL directly: https://yourcompany.atlassian.net/rest/api/3. Add the group-level headers: - Authorization: {{JIRA_AUTH}} (this uses the App Constant you created) - Accept: application/json - Content-Type: application/json All child API Calls inside this group will inherit these headers automatically. You won't need to set the Authorization header per-call. Note: if you also need to call Jira's Agile API (for sprint data), that lives at a different base path: /rest/agile/1.0/. Create a second API Group (JiraAgile) with base URL https://yourcompany.atlassian.net/rest/agile/1.0 for those calls rather than adding them to the same group.

1// API Group configuration reference
2// Group name: Jira
3// Base URL: https://yourcompany.atlassian.net/rest/api/3
4// Headers (inherited by all child calls):
5// Authorization: {{JIRA_AUTH}}   (Basic Base64(email:api_token))
6// Accept: application/json
7// Content-Type: application/json

Inside the Jira API Group, click Add API Call. Name it SearchIssues. Set the method to POST and the endpoint to /search. Jira's search endpoint accepts a JSON body with your JQL query, not URL parameters. Go to the Body tab in the API Call editor. Set the body type to JSON and enter a body with the following structure: {"jql": "{{jqlQuery}}", "maxResults": 50, "fields": ["summary", "status", "assignee", "description", "priority", "issuetype"]}. Now go to the Variables tab and add a variable named jqlQuery with type String and a default value like project = YOUR_PROJECT_KEY ORDER BY updated DESC. This lets you pass different JQL queries from different pages in your app without creating multiple API Calls. Go to the Response & Test tab. Paste a sample Jira search response (a JSON object with an 'issues' array). Click Generate from Response to create JSON Paths. Key paths to use: - Issue key: $.issues[*].key - Summary: $.issues[*].fields.summary - Status: $.issues[*].fields.status.name - Priority: $.issues[*].fields.priority.name - Assignee: $.issues[*].fields.assignee.displayName Do NOT try to bind $.issues[*].fields.description directly — the description is ADF JSON, not a string. You'll handle that in the next step. Click Test API Call. If Jira returns issues, you'll see them in the Response panel. A 401 means your Basic auth credentials are wrong. A 403 means the API token doesn't have access to the project. A 400 with 'The value ... does not exist for the field project' means your project key is incorrect.

1// POST /search request body
2{
3  "jql": "{{jqlQuery}}",
4  "maxResults": 50,
5  "startAt": 0,
6  "fields": [
7    "summary",
8    "status",
9    "assignee",
10    "description",
11    "priority",
12    "issuetype",
13    "created",
14    "updated"
15  ]
16}
17
18// Sample response structure (paste into Response & Test for JSON Path generation)
19{
20  "total": 42,
21  "issues": [
22    {
23      "id": "10001",
24      "key": "ABC-123",
25      "fields": {
26        "summary": "Fix login button on mobile",
27        "status": { "name": "In Progress" },
28        "priority": { "name": "High" },
29        "assignee": { "displayName": "Jane Doe" },
30        "issuetype": { "name": "Bug" },
31        "description": {
32          "type": "doc",
33          "version": 1,
34          "content": [
35            {
36              "type": "paragraph",
37              "content": [
38                { "type": "text", "text": "Steps to reproduce..." }
39              ]
40            }
41          ]
42        }
43      }
44    }
45  ]
46}

Jira's description and comment fields use Atlassian Document Format (ADF) — a rich-text JSON structure, not a plain string. The format wraps text inside nested content arrays: { "type": "doc", "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "your actual text" }] }] }. If you bind $.issues[*].fields.description directly to a Text widget, FlutterFlow will try to display the raw JSON object, which either shows nothing or shows '[object]'. You need a Custom Function to extract just the text nodes. In FlutterFlow, go to Custom Code in the left nav → + Add → Function. Name it flattenADF. Set the return type to String. Add one input parameter named adfJson of type dynamic (or JSON/String). Paste the Dart function below. It recursively walks the ADF content tree, extracts all text nodes, and returns them joined with newlines. This gives you a readable plain-text version of any ADF field. After creating the function, in your issue detail page, add a Text widget for the description. Set its value via Set from Variable → Custom Function → flattenADF, passing the raw description JSON Path as the adfJson argument. Note: Custom Functions in FlutterFlow are synchronous Dart code — no async, no pub.dev dependencies needed. The flattenADF function below is self-contained.

1// Custom Function: flattenADF
2// Add via Custom Code → + Add → Function in FlutterFlow
3// Return type: String
4// Parameter: adfJson (dynamic)
5
6String flattenADF(dynamic adfJson) {
7  if (adfJson == null) return '';
8  
9  // If it's already a string, return as-is
10  if (adfJson is String) return adfJson;
11  
12  final StringBuffer buffer = StringBuffer();
13  
14  void extractText(dynamic node) {
15    if (node == null) return;
16    
17    if (node is Map) {
18      final type = node['type'];
19      final text = node['text'];
20      
21      // Text nodes contain the actual content
22      if (type == 'text' && text != null) {
23        buffer.write(text);
24        return;
25      }
26      
27      // Add newline after paragraph/heading/listItem blocks
28      if (type == 'paragraph' || type == 'heading' || type == 'listItem') {
29        final content = node['content'];
30        if (content is List) {
31          for (final child in content) {
32            extractText(child);
33          }
34        }
35        buffer.write('\n');
36        return;
37      }
38      
39      // Recurse into content arrays for other node types
40      final content = node['content'];
41      if (content is List) {
42        for (final child in content) {
43          extractText(child);
44        }
45      }
46    } else if (node is List) {
47      for (final item in node) {
48        extractText(item);
49      }
50    }
51  }
52  
53  extractText(adfJson);
54  return buffer.toString().trim();
55}

Read operations (GET, POST /search) are safe with credentials in App Constants because the data flows one way and the worst case of credential exposure is read access to your Jira projects. However, creating issues (POST /rest/api/3/issue) is a write operation and sends your API token in the client bundle where it can be extracted. For security, route issue creation through a Firebase Cloud Function. The Cloud Function stores your Atlassian email and API token in server-side environment variables, calls the Jira API on behalf of the app, and returns only the new issue key to the FlutterFlow client. In your FlutterFlow project, create a new API Group named JiraProxy with the base URL pointing to your Firebase Cloud Function endpoint (e.g., https://us-central1-your-project.cloudfunctions.net/createJiraIssue). Add a CreateIssue POST call inside it. The body accepts the issue fields your form collects: summary, description, project key, and issue type. No Authorization header goes in this FlutterFlow API Call — the Cloud Function handles authentication internally. In your create-issue form page, wire the Submit button action to Backend/API Call → JiraProxy → CreateIssue, passing the form field values as body parameters. On success, navigate back to the issue list and trigger a refresh. Also handle the rate limit: Jira Cloud allows approximately 300 requests per minute per user token. If your app polls for issue updates on a timer, add sufficient delay between polls (at minimum 10-20 seconds) to avoid hitting the limit. The API returns a 429 response with a Retry-After header when the limit is exceeded.

1// Firebase Cloud Function: createJiraIssue/index.js
2const functions = require('firebase-functions');
3const fetch = require('node-fetch');
4
5exports.createJiraIssue = functions.https.onRequest(async (req, res) => {
6  res.set('Access-Control-Allow-Origin', '*');
7  res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
8  res.set('Access-Control-Allow-Headers', 'Content-Type');
9
10  if (req.method === 'OPTIONS') {
11    res.status(204).send('');
12    return;
13  }
14
15  const JIRA_EMAIL = process.env.JIRA_EMAIL;
16  const JIRA_TOKEN = process.env.JIRA_API_TOKEN;
17  const JIRA_DOMAIN = process.env.JIRA_DOMAIN;
18  const basicAuth = Buffer.from(`${JIRA_EMAIL}:${JIRA_TOKEN}`).toString('base64');
19
20  const { summary, description, projectKey, issueType } = req.body;
21
22  try {
23    const response = await fetch(
24      `https://${JIRA_DOMAIN}.atlassian.net/rest/api/3/issue`,
25      {
26        method: 'POST',
27        headers: {
28          'Authorization': `Basic ${basicAuth}`,
29          'Accept': 'application/json',
30          'Content-Type': 'application/json'
31        },
32        body: JSON.stringify({
33          fields: {
34            project: { key: projectKey },
35            summary: summary,
36            description: {
37              type: 'doc',
38              version: 1,
39              content: [{
40                type: 'paragraph',
41                content: [{ type: 'text', text: description || '' }]
42              }]
43            },
44            issuetype: { name: issueType || 'Task' }
45          }
46        })
47      }
48    );
49    const data = await response.json();
50    res.status(response.status).json(data);
51  } catch (error) {
52    res.status(500).json({ error: error.message });
53  }
54});