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
Increase productivity and eliminate the need for manual data entry and redundant tasks.
Keep your team focused on core competencies – selling and developing products.
Understand the impact of feature requests on your sales pipeline or other insights.
Get a 360-degree view of your customer interactions.
Convert Salesforce cases or opportunities into actionable Jira tasks with ease.
Tailor the integration to your unique business processes.
Sync Any Data Between Jira and Salesforce
Map standard and custom Salesforce objects any way you want with Jira work items.
Use sync rules to define which data should be synced in your Salesforce to Jira integration.
Salesforce
Case
All fields are supported, including:
- Custom fields
- Account Name
- Asset
- Business Hours
- Case Owner
- Contact Email
- Escalated
- Priority
- Product
- SLA Violantion
- Type
Problems
All fields are supported, including:
- Close Date
- Contract
- Delivery/Installation Status
- Description
- Lead Source
- Order Number
- Opportunity Score
- Price Book
- Probability
- Tracking Number
Change Requests
All fields are supported, incuding:
- Account Owner
- Annual Revenue
- Billing Address
- Customer Priority
- Parent Account
- SIC Code
- Tradestyle
- Upsell
- Year Started
Sync any Salesforce entity
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
Jira Software (Cloud and Data Center)
Jira Service Management
Work Items (Issues)
(Bugs, Tasks, Stories…)
+40 fields are supported, including:
- Custom fields
- Summary
- Status
- Description
- Key
- Comment
- Attachment
- Priority
- Third-party plugin fields (e.g Insights)
Sprints
All fields are supported, incuding:
- Name
- State
- Start date
- End date
- Complete goal
- Origin board ID
- Goal
“
Its hard to talk about supported fields, because with Exalate you can support a lot. And it is impossible to capture on a single page. We have done cases with very weird things - certainly not limited to the ones listed on the documentation.
discover if we cover your integration requirements
Book a demo to see Exalate in action
Get the Most Out of Your Integration
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.
“
The fact that Exalate is a very extensible and flexible product is quite an impressive feature for us. We can even build our own integration on top of it, and it actually shows that the developers and the engineers behind the product do really know what they are doing. Plus we have had an excellent customer experience.
Alexander Sinno |
Simple or Advanced, We Got you Covered
Work with simple integration templates. Or, completely customize your sync.
In practice:
...Or simply write a few lines of code
entity.entityType == “Custom Object Name”
replica.customFields.”CF Name” = issue.customFields.”CF Name”
In practice:
...Or simply write a few lines of code
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
In practice:
...Or simply write a few lines of code
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|”””
}
In practice:
...Or simply write a few lines of code
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
}
In practice:
No need to code, simply add a trigger.
In practice:
In practice:
...Or simply write a few lines of code
//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
Unify Data Formatting Between Jira and Salesforce
Jira work item names and Salesforce campaign names employ different logic and syntax for storing values. The same applies to the values of names in dropdown lists. Exalate uses transformers to convert these values to a readable format for either system so that the correct information is sent.
Unify Data Formatting Between Jira and Salesforce
Instead of manually duplicating contract data from Salesforce to Jira, automate the process using conditional logic and triggers to streamline the workflow. Every child ticket or task resulting from each contract will send updates to the attached Salesforce account.
“
We can now handle around 500 customer incidents per week, thanks to Exalate, which is a very good result regarding the number of products we’re dealing with. It synchronizes 45x faster than our previous solution.
Christof Cuyper |
Set up, Customize, Sync!
01
connect
Connect the tools you want to integrate. Just add the instance’s URL.
02
customize
Configure your sync rules to make sure the right data is shared. Prompt the sync rules with Aida AI, or write your scripts from scratch.
03
automate
Set conditions with triggers, for an automatic synchronization.
04
synchronize
Now your instances are connected and will automatically exchange information instantly. Happy syncing!
See it in action
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.