Detailed Steps for Integrating Jira with Salesforce using native API and no connectors

[John Funk]

The desire is to connect Jira and Salesforce with the native APIs using new Jira Service Account. The goal is that when the status of an object (for example Opportunity) reaches a certain value, then create a work item in JSM and copy values from SF to Jira based on mapping. 

Has anyone done this? Can you provide step-by-step process for a non-developer to be able to achieve the goal? 

[Jayesh Raghuvanshi]

@John Funk 

Yes — this is totally doable without heavy development. Below I’ll give a clear, non-developer step-by-step you can follow to: create a Jira service account + API token, map the Salesforce Opportunity fields you care about, and use a Salesforce Flow + Named Credential (no Apex) to call the Jira Cloud REST API and create a JSM work item when an Opportunity reaches a target stage. I’ll include sample JSON, a curl test you can run, troubleshooting tips, and links to the official docs for the important steps.

High-level approach (one-line)

When Opportunity → desired stage, Salesforce Record-Triggered Flow uses a HTTP Callout action that calls Jira Cloud REST POST /rest/api/3/issue using a Named Credential that stores a Jira service account + API token.

What you’ll need (prereqs)

Jira Cloud admin access (to create a service account or a managed service account and give it project permissions). Atlassian supports service accounts and org admins can create credentials for them.

Salesforce admin access (to create Named Credentials, External Credentials if needed, and build Flows).

A simple mapping spreadsheet (Salesforce field ↔ Jira field). (I provide a sample below.)

Postman or curl (for testing the Jira API before wiring Flow).

Step-by-step (non-developer friendly)
A — Jira side: create the service account + API credential

Create a Jira service account (or use Atlassian “service account” if you have org admin). Make sure it has product access to the JSM project and project permissions at minimum: Create issues, Add attachments (if needed), Edit issue fields. (Service accounts can be managed centrally.)

Create an API token for that account (you’ll use the token instead of a password). Log into the Atlassian account and create/manage API tokens. Copy the token — you can’t view it again later.

Decide JSM target: note the project key (e.g., JSM) and the Issue Type name you want (e.g., Service Request) and any required fields in that project (summary/issuetype/project are required). You’ll need those in the JSON payload.

B — Prepare your field mapping (use this first)

Create a tiny spreadsheet with columns: Salesforce field | Jira field (name or customfield_xxx) | Notes / transform. Example:

Salesforce field Jira field Notes
Opportunity.Name summary prefix: "Opportunity: "
Opportunity.StageName description include "Stage: {!StageName}"
Opportunity.Amount customfield_10026 map to a text/number custom field
Opportunity.Owner.Name customfield_10027 optional

How to get a Jira custom field id if you need to set custom fields (you’ll need customfield_100xx): open an issue that shows that field and Inspect the field element OR go to Jira Admin → Issues → Custom fields → Edit details and check the URL (it contains the customFieldId). Atlassian docs show this.
confluence.atlassian.com

C — Test the Jira API manually (quick sanity check)

Why: confirm your Jira service account + token + payload will create an issue before automating from Salesforce.

Example curl (replace placeholders):

curl -v -u "jira_service@example.com:YOUR_API_TOKEN" \
-X POST \
-H "Content-Type: application/json" \
-d '{
"fields": {
"project": { "key": "JSM" },
"summary": "Opportunity: Big Deal - Stage Closed Won",
"description": "SF Opportunity URL: https://yourDomain.lightning.force.com/006XXXXXXXXXXXX\nAmount: 10000",
"issuetype": { "name": "Service Request" },
"customfield_10026": "10000"
}
}' \
"https://your-domain.atlassian.net/rest/api/3/issue"

A successful response returns 201 Created and JSON containing the new key and id. (See Atlassian create-issue docs for JSON format.)
Atlassian Developer

If curl returns 401 → check email/token, 403 → check project permissions, 400 → check payload (field names/customfield ids).

D — Salesforce side (no code) — create Named Credential & Flow
1) Create the Named Credential (store Jira creds safely)

In Salesforce Setup → Named Credentials → New:

Label/Name: Jira_Service

URL: https://your-domain.atlassian.net

Identity Type: Named Principal (so Flow uses the single Jira service account)

Authentication Protocol: Password Authentication (username & password fields). Put Jira service account email as username and API token as password. (Salesforce uses the Named Credential so you don’t hand Authorization headers around.)

Save. Trailhead shows how to wire Named Credentials for HTTP Callout actions.

Note: if your org requires a different auth style you can configure OAuth or an Auth Provider. For basic API token usage the username/api_token approach is straightforward.

2) Build a Record-Triggered Flow (Opportunity)

In Salesforce Setup → Flows → New Flow → Record-Triggered Flow:

Object: Opportunity

Trigger: A record is updated

Entry conditions: StageName = 'TargetStage' AND ISCHANGED(StageName) (so it only runs when the stage actually changes)

Configure run: after save (so you can update Opportunity after callout)

Add Action: choose the Flow action HTTP Callout (or Send HTTP Request — Flow’s HTTP Callout action).

Named Credential: pick Jira_Service (the one you created).

Method: POST

Endpoint / Path: /rest/api/3/issue (the Named Credential base is the domain; you give the path)

Headers: Content-Type: application/json and Accept: application/json (Authorization is handled by Named Credential)

Body: convert your mapping into JSON. Example body using Flow merge fields ($Record variables):

{
"fields": {
"project": {"key":"JSM"},
"summary": "Opportunity: {!$Record.Name} - Stage {!$Record.StageName}",
"description": "Salesforce URL: https://yourDomain.lightning.force.com/{!$Record.Id}\nOwner: {!$Record.Owner.Name}\nAmount: {!$Record.Amount}",
"issuetype": {"name":"Service Request"},
"customfield_10026": "{!$Record.Amount}"
}
}

Save the HTTP action output into a Flow variable (the HTTP Callout action returns status and response body).

After the callout, parse the response (Flow can parse JSON using the action's "Output" or use a Text variable). Pull response.key (e.g., JSM-123) and update the Opportunity with a field Jira_Link__c or Jira_IssueKey__c containing the Jira URL https://your-domain.atlassian.net/browse/{key}.

Trailhead has details on how to create the Named Credential and wire it into an HTTP Callout in Flow.

E — Error handling & logging (non-developer approach)

In your Flow, check HTTP response code:

If 201 → success; update Opportunity with Jira key.

Else → create a record in a simple custom object Integration_Log__c capturing: Opportunity Id, timestamp, status code, response body. Optionally send an email alert to admin.

For transient errors or 429 rate limits, surface them to the log and notify. Implement manual retry policy (admins can re-run failed logs) — this avoids coding. Atlassian documents rate limiting and you should handle 429 gracefully.

F — Attachments or complex data

Attachments are more complex: Jira requires multipart POST /rest/api/3/issue/{issueIdOrKey}/attachments with X-Atlassian-Token: no-check header. Flow’s standard HTTP Callout has limited multipart support, so attachments usually need middleware or a small Apex piece. See Atlassian attach API docs for details.

Full quick checklist (do this in order)

Create Jira service account & API token; give it correct project permissions.

Decide project key and issue type in JSM; list required fields.

Make a mapping spreadsheet (SF → Jira customfield ids if needed).
confluence.atlassian.com

Test with curl or Postman to create an issue (confirm credentials + payload).

In Salesforce: create Named Credential pointing to https://your-domain.atlassian.net.

Create a Record-Triggered Flow on Opportunity, add an HTTP Callout action using the Named Credential, parse the response, update Opportunity.

Add logging + alerts for failures; handle rate-limit responses.