Overview

MirthSync Overview

MirthSync is an open-source command-line tool with embedded Git that brings Git-based version control and CI/CD automation to Mirth Connect and Open Integration Engine (OIE) environments. Transform your integration platform configurations into files, enable modern DevOps workflows, and bring healthcare integration management into the 21st century—no separate Git installation required.

What is MirthSync?

MirthSync brings modern software delivery practices to Mirth Connect and Open Integration Engine by turning server-stored configurations into version-controlled files. Channels, code templates, and environment settings become part of your repository, so you can manage integration work with the same rigor you use for application code.

Key benefits include:

Git-native workflows – Track every change, branch safely, and keep a permanent audit trail.
Automation ready – Feed configurations into CI/CD pipelines, automated testing, and deployment workflows without custom scripting.
Team friendly – Review changes through pull requests and collaborate without clashing edits in the admin console.
Embedded Git – No separate Git installation needed. MirthSync includes Git functionality built-in.

Why the Traditional Approach Falls Short

Relying on the built-in database exports leaves teams without essential DevOps safeguards:

No reliable history – You can’t see who changed a channel or why, and rollback capabilities are manual guesswork.
Risky deployments – Deployment across environments requires error-prone imports with no automated validation.
Limited collaboration – Multiple editors overwrite each other, and there’s no structured review process.

As integration footprints grow, these gaps lead to configuration drift, compliance risk, and long recovery times when something breaks. MirthSync closes that gap by treating your integration platform as infrastructure as code, enabling consistent, auditable, and automated operations across every environment.

How MirthSync Works

MirthSync connects to your Mirth Connect or Open Integration Engine server via the REST API, extracts configurations, and converts them into a structured file format on your local machine. The process is straightforward:

1️⃣ Extract configurations from your server

Pull configurations from your Mirth Connect or OIE server:

java -jar mirthsync.jar -s https://mirth.example.com:8443/api -u admin -t ./mirth-config pull

This command connects to your server via the REST API, retrieves all channels, code templates, and configurations, and saves them as organized files in your project directory. Use the MIRTHSYNC_PASSWORD environment variable for secure password management.

2️⃣ Work with files using standard tools

Once configurations are files, you can use any tool in your development toolkit:

Edit channels in VS Code or IntelliJ with full IDE features (syntax highlighting, autocomplete, refactoring)
Track changes with Git and see exactly what was modified in each commit
Search globally across all channels with grep or your IDE’s search
Refactor code templates with find-and-replace across the entire project
Compare versions to understand what changed between releases

3️⃣ Version control with Git

Commit your changes to Git just like you would with application code:

java -jar mirthsync.jar -t ./mirth-config git add
java -jar mirthsync.jar -t ./mirth-config --commit-message "Add patient ADT channel with HL7 validation" git commit
java -jar mirthsync.jar -t ./mirth-config git push

Benefits of Git version control:

See who modified which channel, when they made the change, and why (through commit messages)
Rollback to any previous version instantly
Create branches for feature development
Merge changes through pull requests with code review
Maintain a permanent audit trail for compliance

4️⃣ Deploy to any environment

Push your file-based configurations back to any Mirth Connect or Open Integration Engine environment:

java -jar mirthsync.jar -s https://mirth-prod.example.com:8443/api -u admin -t ./mirth-config --deploy-all push

MirthSync handles the conversion from files back to the format your server expects, deploying your configurations safely and consistently. Manage multiple environments by pointing to different server URLs—use separate directories or Git branches for dev, staging, and production configurations.

5️⃣ Automate with CI/CD

Integrate MirthSync into your existing CI/CD pipelines:

GitHub Actions – Automatically test and deploy on every commit
Jenkins – Integrate into existing Jenkins workflows
GitLab CI – Use GitLab’s built-in CI/CD
Azure DevOps – Deploy through Azure Pipelines
Any platform – Works with any CI/CD tool that can run bash commands

Enable continuous deployment for your integration platform just like you do for application code.

File-Based Structure

MirthSync creates an organized directory structure that works seamlessly with standard DevOps tools:

my-mirth-project/
├── Channels/
│   ├── Default Group/
│   │   └── ADT_Inbound/
│   │       ├── channel.xml
│   │       ├── sourceConnector.js
│   │       └── transformer.js
│   └── Production Group/
│       └── Lab_Results/
│           └── channel.xml
├── CodeTemplates/
│   ├── Utilities/
│   │   ├── library.xml
│   │   └── parseHL7.js
│   └── helpers.xml
├── GlobalScripts/
├── Resources/
└── ChannelGroups/

Structure benefits:

One channel per directory – Each channel has its own folder with configuration and metadata, making it easy to find and modify specific channels
Human-readable files – XML and JSON formats can be edited in any text editor, reviewed in pull requests, and tracked in Git
Flat hierarchy – Simple structure that’s easy to understand and navigate, whether in a file explorer or command line
Git-friendly – Designed for version control with clear file boundaries and meaningful diffs

Once your configurations are files, you unlock the entire ecosystem of modern development tools:

What you can do:

Search globally: grep -r "patient.name" channels/ to find all references across every channel
Mass refactoring: sed -i 's/oldEndpoint/newEndpoint/g' channels/**/*.xml to update endpoints everywhere
IDE power: Open channels/ in VS Code and use multi-cursor editing, IntelliSense, and refactoring tools
Code review: Create pull requests in GitHub/GitLab and review changes with inline comments before deployment
Automated testing: Run validation scripts in CI/CD pipelines before configurations reach production
Version control: See exactly what changed between versions with mirthsync git diff instead of manual comparison

You’re no longer limited to the Admin Console GUI—you can use the tools that make you most productive.

Getting Started

Ready to bring version control to your Mirth Connect or Open Integration Engine environment?

Quick overview:

Download MirthSync JAR from GitHub Releases
Set your password: export MIRTHSYNC_PASSWORD=yourpassword
Pull configurations: java -jar mirthsync.jar -s https://server:8443/api -u admin -t ./mirth-config pull
Start using Git for version control

→ Get Started with Installation Guide