Stop wasting hours on manual updates. Sync cases, accounts, work itens and more between Salesforce and Jira. Automatically and in real-time.
Let Sales, Support, and Engineering stay perfectly aligned.

sync issue types, labels, priority, status...
sync any custom fields, attachments...
sync comments, worklogs, history...
sync opportunity, case, taks, account, product...
sync owner, status, number, priority...
sync contact details, internal comments...

3.5/4
Highest Rated Integration App on the Atlassian Marketplace





Sync any entity using a one or two-way mapping. Configure and map the entities precisely as you require them.

All fields are supported, including:
All fields are supported, including:
All fields are supported, incuding:
Exalate for Salesforce allows syncing all the available objects and their fields within the Script connection. This page only shows the most popular and widely used objects and their fields.

Jira Software (Cloud and Data Center)
Jira Service Management
(Bugs, Tasks, Stories…)
+40 fields are supported, including:
All fields are supported, incuding:

Easily connect multiple projects, instances, and platforms. With local, or external partners.
Set your sync rules to make sure the right data is shared.
Prompt Exalate’s AI to generate rules, or fine-tune with Groovy-based custom mappings and logic for complete control.
Set triggers to automate your sync based on specific conditions.
Now your connected instances will exchange information automatically. Happy syncing!




Connect multiple projects, instances, and platforms. Use different rules for each connection.

Get AI-powered recommendations for resolving the issue, including possible fixes and next steps.


Exalate comes with default sync rules, that can be adapted to your specific needs.
Build your unique integration rules with just a few lines of Groovy Script – or a few prompts.




Work with simple integration templates. Or, completely customize your sync.
Set up one-way or two-way syncs between new or existing Jira and Salesforce entities. Sync issues, epics, sprints, etc in Jira. Sync any Salesforce entity such as cases, accounts, opportunities, contacts, custom objects, etc. Map fields by configuring the sync rules. Start automatic sync with triggers.
Control your Jira Salesforce sync at a granular level.

Sync standard and custom Salesforce objects with custom Jira fields. Update the connected Salesforce Account details from the corresponding custom field in Jira.

entity.entityType == “Custom Object Name”
replica.customFields.”CF Name” = issue.customFields.”CF Name”

Sync custom fields in Salesforce like Date or Date/Time by converting them into a common format for Jira.

import java.text.SimpleDateFormat;
import java.text.DateFormat;
def dateCustomFieldValue(replicaCustomField) {
def datePattern = “yyyy-MM-dd HH:mm:ss.S”; // define the desired date/time format
String dateString = replicaCustomField.value;
if (dateString) {
dateString = dateString.replaceAll(“\””,“”).trim();
DateFormat formatter = new SimpleDateFormat(datePattern);
date = formatter.parse(dateString);
return date.time;
}
}
entity.date__c = (Long) dateCustomFieldValue(replica.customFields.“DateCf”)
entity.datetime__c = (Long) dateCustomFieldValue(replica.customFields.“Date

Present a Salesforce case object containing a contact and a linked account on the Jira side.

if (replica.”TYPE” == “Case”) {
if(firstSync){
issue.projectKey = “UD”
issue.typeName = “Task”
syncHelper.syncBackAfterProcessing()
}
issue.summary = replica.summary
issue.description = replica.description
issue.comments = commentHelper.mergeComments(issue, replica)
issue.attachments = attachmentHelper.mergeAttachments(issue, replica)
}
else if (replica.”TYPE” == “Contact”) {
def contact = issue.”SF Contact”
if (contact == null || contact.trim() == “”) {
contact = “””||Name:| ||Title:| |||Email:| || | |”””
}
def name = replica.”Name”
def title = replica.”Title”
def email = replica.”Email”
issue.”SF Contact” = “””|| Name | $name |
|| Title | $title |
|| Email | $email|”””
}
else if (replica.”TYPE” == “Account”) {
def name = replica.”Name”
def description = replica.”Description”
issue.”SF Account” = “””|| Name | $name |
|| Description | $description|”””
}

Sync comment threads and user mentions between Jira and Salesforce. Also, personalize the comment sync based on use case.

replica.comments = issue.comments.collect {
comment ->
def matcher = comment.body =~ /\[~accountid:([\w:-]+)\]/
def newCommentBody = comment.body
matcher.each {
target = nodeHelper.getUser(it[1])?.email
newCommentBody = newCommentBody.replace(it[0],target)
}
comment.body = newCommentBody
comment
}

Cases coming in from Salesforce need to be forwarded to three different work types based on status, urgency, assignee, etc. So the incoming case will appear as a support ticket, bug, or feature request.

Insights in Jira will prompt our Jira to Salesforce integration REST API to sync work items/tickets to Salesforce opportunities.
If you add an insight to a Jira ticket, it will automatically populate a field in the Salesforce opportunity with the number and status of that Jira ticket.


Select an item from a picklist field in the Salesforce case and sync it to a Jira work item’s custom field.

//Jira outgoing sync
issue.customFields.“Hobby”.value = replica.priority?.value ?: “Running”
//Running will be set as a default option if Priority has no selected option
//Salesforce incoming sync
entity.SuppliedCompany = replica.customFields.“text”.value

Christof Cuyper |

Exalate offers a 30-day Free Trial
Small teams with straightforward synchronization needs
Growing teams with moderate synchronization volume
Organizations needing enterprise systems
pricing per integration starts atThis is the entry price for the lowest-cost integration. Your price depends on which systems you connect, items in sync, environments, SLA/support, and add-ons. To get a tailored quote, contact sales.
$
550
/mo
Billed annually
Large-scale deployments with custom requirements
Let's talk
Get in touch for your custom pricing














& more





Set up and configure connections between Jira and Salesforce, in any way you prefer. Control the direction of your data flow and choose between a one-way or a two-way sync.
Streamline your business workflows with automated, real-time Jira Salesforce sync. Reduce the need for manual work. Enhance control over data flow using custom triggers in the platform’s native query language.
Sync historical data with bulk operations in Exalate. Connect multiple existing entities using Bulk Connect. Start syncing entities automatically with the same trigger specifications using Bulk Exalate.
Let your developers implement various sync possibilities using the Groovy-based scripting engine. Create scripts that manage synchronization on your end without affecting the destination.
Test your connection, view sync status or connect existing entities with an integrated Exalate UI in Jira and Salesforce. Always stay up-to-date within the platform you use.





Answers to the most frequently asked questions
Exalate syncs any Jira work item (bugs, tasks, stories, epics, sprints) with any Salesforce object (cases, opportunities, accounts, contacts, products, or custom objects). You can map and transform entity fields, including summaries, descriptions, comments, attachments, statuses, priorities, and custom fields. Third-party plugin fields like Elements Connect or Insight are also supported.
Exalate uses single-tenant architecture to isolate your data at the infrastructure level. Security features include JWT access tokens, role-based access controls, HTTPS with TLS 1.2/1.3 encryption, and more. Each side of your integration maintains independent control, so no need to share credentials or admin access with integration partners.
Visit Exalate’s Trust Center for more details.
Exalate uses outcome-based pricing where you pay for active items in sync, not per user or transaction. All plans start with a 30-day free trial. Pricing scales with actual business value: you’re charged for items currently syncing, not historical volume or API calls.
Check out the pricing models or estimate the costs here.
Yes, Exalate supports multi-node setups connecting multiple Jira instances, multiple Salesforce orgs, or combinations of both. From a unified console, you can manage all your connections and integrations in one place. Exalate also connects to Azure DevOps, ServiceNow, Zendesk, GitHub, and more, enabling company-wide and cross-company integration networks.
MuleSoft is Salesforce’s native iPaaS solution designed for enterprise API management across many systems. Exalate specializes in real-time, bidirectional sync between work management platforms like Jira and Salesforce. Key differences: Exalate offers granular field mapping with Groovy scripting, requires no API expertise to configure, and supports cross-company integrations where each party maintains independent control of their data and rules.
Yes, Exalate supports full bidirectional synchronization between Jira and Salesforce. Changes made in either system automatically reflect in the other in real time. You control the sync direction for each field: sync comments both ways, sync status one way, or any combination. Each side maintains independent rules, so adjustments on one side don’t affect the other’s configuration.
Exalate uses each platform’s native query language for triggers. In Jira, you write JQL queries (e.g., project = "Support" AND priority = High). In Salesforce, you use SOQL queries. Triggers can be based on any field conditions, like issue type, status, priority, custom field values, or any combination. This gives you precise control over which items sync and when.
Yes, Exalate fully supports Jira Service Management (JSM) alongside Jira Software and Jira Work Management. You can sync Salesforce Cases to JSM service requests, incidents, or problems. Field mappings include case number, priority, SLA status, customer details, and any custom fields. Status updates flow both ways, so support teams stay aligned without switching between platforms.
Yes, Exalate syncs both standard and custom fields. You can map Jira custom fields (checkboxes, dropdowns, user pickers, date fields, etc.) to Salesforce custom fields and vice versa. Sync scripts let you transform values between different field types, for example, mapping a Jira dropdown to a Salesforce picklist with different option names.
Set up a trigger using SOQL in Salesforce, for example, when an Opportunity reaches “Closed Won” stage. Exalate automatically creates a Jira issue with mapped fields like account name, deal value, and expected close date. Configure field mappings in your sync rules to determine which Salesforce fields populate which Jira fields. Updates flow back to Salesforce as the Jira work progresses.