Redmine to Jira migration
We migrate Projects, Issues, Time Entries, Versions, and Custom Fields from Redmine into Jira with the Tracker-to-Issue-Type schema resolved upfront, attachment files copied from the filesystem and re-linked by Issue key, and issue history extracted from the journals table where CSV export alone would lose it.
FlitStack AI migrates projects, issues, fix versions, worklogs and custom fields from Redmine to Jira, with their history and the associations between records. Every field is mapped and validated, a sample run is checked with you before the full migration, and the whole move can be rolled back in one click. Typical timeline: 3-5 weeks.

What moves from Redmine to Jira?
Moving from Redmine to Jira is a structural migration that requires resolving several platform-specific gaps before any data moves.
Read the full summary
Redmine has no native CSV import loop—its export captures a current-state snapshot with no history, while Jira expects Issue Types, Workflows, and Screen schemes as prerequisites before import. We handle this by reading Redmine via its REST API or direct database access, pre-creating the Jira project schema (Issue Type schemes, Status mappings, custom field definitions), then importing in dependency order. Attachments require separate filesystem handling because Redmine stores them on disk under /files, not in the database. Jira's per-issue-type Workflow model also means each Tracker in Redmine must be mapped to a Jira Issue Type with its own workflow configuration. We do not migrate Workflows, automations, or plugins as code; we deliver a written inventory of these for the customer's admin to rebuild post-migration.
Project → Project
Redmine Projects map directly to Jira Projects.
How it maps
We pull the full project hierarchy including subprojects via Redmine's REST API (or direct DB query) and recreate the parent-child structure in Jira as Jira Projects with parent Project keys. Project description, enabled modules, and lead user migrate. Note that Jira requires project administrators to configure the project before data import can begin.
Issue → Issue
Redmine Issues map to Jira Issue Type scheme entries.
How it maps
We map Tracker values (Bug, Feature, Support, etc.) to Jira Issue Types (Bug, Story, Task, Epic) that we pre-create in the target project. Standard fields—subject, description, status, priority, assignee, reporter, due date, start date—migrate directly. Custom field values migrate as a secondary step after Jira custom fields are created and mapped. Note that CSV exports exclude issue history from the journals table; we extract journals separately via direct DB query or REST API and append them as Jira comments with a [Migrated from Redmine] prefix and original timestamp.
Version → Fix Version
Redmine Versions (milestones) map to Jira Fix Version values.
How it maps
Each Version carries a name, description, due date, and status (open, locked, closed) that transfer directly as Jira Fix Versions within the target project. We pre-create all Versions before importing Issues so that Fix Version can be set during Issue migration.
Time Entry → Worklog
Redmine Time Entries map to Jira worklog entries.
How it maps
Each Time Entry carries hours, activity (enumeration), comments, user, and date. We preserve hours and comments as Jira worklog (via Tempo if the customer licenses it, or via the native worklog API on applicable Jira tiers). Note that Jira's free tier does not include native worklog; we flag this gap during scoping and the customer decides whether to license Tempo or accept worklog as out-of-scope.
Custom Field → Custom Field
Redmine Custom Fields are defined separately via /custom_fields.json and apply to specific object types.
How it maps
We retrieve all Custom Field definitions first (name, format, possible_values, multiple flag), then create equivalent Jira Custom Fields in the target project. Text, number, date, list, boolean, and user Custom Fields map to Jira's text field, number field, date picker, single/multi-select, checkbox, and user picker respectively. Custom fields must be created and assigned to the relevant Issue Type scheme before Issue import begins.
User → User
Redmine Users (login, first name, last name, email, admin flag) map to Jira Users.
How it maps
We match by email address during migration. Note that Redmine does not store password hashes compatible with Jira's authentication model (Atlassian account, SAML, or LDAP), so migrated users must receive Jira invitations or be provisioned via the customer's identity provider post-migration.
- ProjectProject1:1
- IssueIssue1:1
- VersionFix Version1:1
- Time EntryWorklog1:1
- Custom FieldCustom Field1:1
- UserUser1:1
+ 4 more in the mapping below
How Redmine and Jira differ
The differences that decide how each record is mapped. These are what a CSV export and a native importer don't resolve for you.
| Dimension | Redmine | Jira |
|---|---|---|
| Issue Type model | Single Issue object with Tracker enumeration (Bug, Feature, Support) | Separate Issue Type scheme per project with Story, Bug, Epic, Task, Sub-task |
| Workflow structure | Global status enumerations per tracker | Per-Issue-Type workflow with transitions, conditions, and validators |
| Time tracking | Built-in Time Entries as first-class objects linked to Issues | Work Logs via Tempo or legacy Log Work; not standard on free tier |
| Custom fields | Defined separately via /custom_fields.json, applied to specific object types | Defined per Issue Type scheme; must be created before data import |
| Attachment storage | Files on filesystem under /files, metadata in database | Stored as Jira attachments via API or upload, linked to Issue key |
| REST API | Disabled by default; must be explicitly enabled in Admin settings | Always available via /rest/api/latest with OAuth or API token auth |
| Agile support | Not native; requires plugins for Kanban and Scrum boards | Built-in Scrum and Kanban boards, backlogs, and sprints from free tier onward |
What to watch for in a Redmine to Jira migration
The issues we plan around on this pair: limits and data-model gaps that the official import tools leave to you.
CSV export captures no issue history
Redmine's built-in CSV export for Issues returns only the current state of each record.
How we handle it
Every status change, journal entry, and comment logged in the Issue's history is not included. Teams that rely on Redmine's activity log for audit trails, client communication history, or code review context lose that data if only CSV is used. We address this by querying the journals and details tables directly via Redmine's database or REST API and appending the history as Jira comments with the original timestamp and author preserved.
Attachments reside on the filesystem, not the database
Redmine stores uploaded files on disk under the /files directory (or a configured storage path), not as BLOBs in the database.
How we handle it
The database holds only the filename, content type, and disk path. A database-only migration will result in empty attachment stubs in Jira with no actual file content. We explicitly enumerate the /files directory during discovery, copy its contents, and re-upload each file to Jira via the REST API or file upload endpoint, using the Issue identifier to relink them. Customers with large attachment volumes should expect this step to extend the migration timeline significantly.
Jira requires pre-configured Issue Type and workflow schemes
Jira requires the project schema to exist before Issues can be imported.
How we handle it
This means Issue Types, Status values, a Workflow with transitions, an Issue Type scheme, and a Screen scheme must all be created and configured before the first Issue is inserted. Redmine has no equivalent schema prerequisite—Issues can be created without declaring types or workflows upfront. We pre-create the Jira project schema during scoping and validate it in a test environment before production migration. Skipping this step results in every import attempt returning validation errors.
Redmine's REST API must be explicitly enabled
Redmine ships with its REST API disabled by default.
How we handle it
Administrators must enable it in Administration > Settings > API before any API-based migration proceeds. We check API availability during discovery and fall back to direct database access (MySQL or PostgreSQL) if the API is unavailable, rate-limited, or returns incomplete data. Direct DB access requires read credentials to the Redmine database, which some hosting providers restrict. We flag both access paths during scoping.
Custom field definitions require a separate discovery call
Custom Fields in Redmine are defined separately from the Issue records that use them.
How we handle it
We must call /custom_fields.json to retrieve all field definitions—name, format, possible_values, multiple flag, and object type—before mapping any Issue or Time Entry data. Without this step, custom field values migrate with incorrect types or are silently dropped. We build a custom field dictionary during discovery and use it to pre-create Jira Custom Fields before the main import phase.
How the migration runs
Discovery and access validation
We audit the Redmine installation: version number, enabled plugins, database type (MySQL or PostgreSQL), REST API status, file storage path, active Custom Field definitions, Tracker list, enumeration values, and project hierarchy including subprojects.
What this step covers
We confirm access paths (API token or DB credentials) and validate that Jira's target environment is accessible. The discovery output is a written migration scope, a pre-flight checklist, and a Jira project schema design document.
Jira project schema pre-configuration
We pre-create the Jira project structure before any data migration begins.
What this step covers
This includes creating the Jira Project, configuring the Issue Type scheme (mapping each Redmine Tracker to a Jira Issue Type), building the Status and workflow definitions, pre-creating Fix Versions, and defining Custom Fields with correct types and contexts. The schema is validated in a Jira test environment or sandbox before production migration to avoid validation errors during import.
User and Group provisioning plan
We extract all Redmine Users and Groups and map them to Jira Users and Groups.
What this step covers
Users are matched by email address. Any User without a Jira account is placed in a reconciliation queue for the customer's admin to provision via Atlassian account invite, SAML SSO, or directory sync before the migration runs. Groups are documented with their Redmine role assignments for the admin to apply via Jira Permission Schemes post-migration.
Attachment enumeration and filesystem copy
We enumerate the Redmine /files directory during discovery, catalog each file by its Issue identifier, and copy the full directory structure to a staging location.
What this step covers
Each file is then re-uploaded to Jira via the REST API and linked to its corresponding Issue key after the Issues themselves have been created. Large attachment volumes extend the migration timeline proportionally. We flag file size limits (32 MB on Jira Cloud) and missing files during this step.
Issue and history migration in dependency order
We run the migration in record-dependency order: Versions first (so Fix Versions exist when Issues reference them), then Issues with custom field values mapped from the pre-built custom field dictionary, then Time Entries as worklog entries, then attachment re-upload and linking.
What this step covers
Issue history (journals, status changes, comments) is extracted from the Redmine database and appended as Jira comments with original author and timestamp. Each phase emits a row-count reconciliation report before the next begins.
Cutover, validation, and automation rebuild handoff
We freeze Redmine writes during cutover, run a final delta migration of any Issues or Time Entries modified during the migration window, then enable Jira as the system of record.
What this step covers
We deliver a written inventory of Redmine Workflows, automations, and plugin-based features that do not migrate, with Jira equivalents for the customer's admin to rebuild. We support a one-week hypercare window for reconciliation issues. Workflow rebuild and Jira admin training are outside the standard migration scope.
Redmine - Connect
- Map
- Sample
- Migrate
- Verify
- Contacts48,210 / 48,210 Done
- Companies9,134 / 9,134 Done
- Deals6,377 / 11,920 In progress
- Before sample runRestore point 01Restore
- Before full migrationRestore point 02Restore
- After verificationRestore point 03Current
How long it takes, and what drives the quote
A quote scales with issue volume, attachment file count, custom field complexity, and whether Jira is Cloud or Data Center. Every quote is scoped with you; there is no self-serve pricing.
Get a quote for Redmine to Jira →Why teams move from Redmine to Jira
- Teams cite Redmine's lack of native Agile boards as the reason for switching. Scrum boards, sprint planning, backlog management, and burndown charts require third-party plugins on Redmine, while Jira includes Scrum and Kanban boards built-in from its free tier. Reviewers on G2 and Capterra describe managing sprints in Redmine as cumbersome and inconsistent across plugin versions.
- Redmine's installation and ongoing maintenance impose hidden costs that accumulate over time. While the software is free, hosting fees, paid plugins for enterprise features (EasyRedmine, Structure), and IT administration time for Ruby-on-Rails maintenance exceed what Jira's per-user pricing costs for teams without dedicated server administrators. Capterra reviews note the total cost of ownership diverges once you factor in the self-hosting overhead.
- Redmine's REST API is read-only by default and must be explicitly enabled by an administrator, limiting automation and integration options. Jira's REST API is always available and powers integrations with CI/CD pipelines, Slack, GitHub, and Confluence without requiring the customer to modify server settings. Teams with Atlassian ecosystem adoption move to Jira because the API is a first-class product, not a configuration step.
- Enterprise and Fortune 1000 companies cite compliance and data governance as drivers for switching. Jira offers SOC 2 Type II, ISO 27001, GDPR, and HIPAA compliance attestations, along with granular permission schemes and audit logs. Redmine's compliance posture depends on the hosting infrastructure and does not carry enterprise compliance certifications, making it unsuitable for regulated industries without significant custom hardening.
- Redmine has no dedicated customer support team. Users rely on community forums, wikis, and self-service documentation. Jira offers tiered support from community forums (free) through 24/7 enterprise support with dedicated phone lines on Premium and Enterprise. Teams with operational SLAs or limited internal IT capacity cite the support gap as a driver for switching to Jira.
Questions, answered
Redmine to Jira migration questions
How long does a Redmine to Jira migration take?
Most migrations land between three and five weeks for environments under 10,000 Issues with no more than a few custom fields and moderate attachment volumes. Migrations with large attachment directories (hundreds of GB of files in Redmine's /files), extensive custom field definitions across multiple object types, or Jira Cloud destinations requiring pre-import schema configuration extend to eight to twelve weeks. Large subproject hierarchies add planning time for Jira project structure but do not proportionally extend data migration time.
Do Redmine Workflows, plugins, and automations migrate to Jira?
No. Redmine Workflows are managed through roles, trackers, and status enumerations—a configuration model that has no direct Jira equivalent. Jira uses per-Issue-Type workflows with transitions, conditions, validators, and post-functions that are architecturally different. Plugins (Structure, EasyRedmine, third-party add-ons) do not have Jira equivalents and require separate evaluation. We do not migrate automations as code. We deliver a written inventory of active Redmine workflows and automations with recommended Jira equivalents (Jira Automation, ScriptRunner if applicable) for the customer's admin to rebuild post-migration.
Can we preserve issue history (status changes, comments, journals) during migration?
Yes, but not through Redmine's built-in CSV export, which captures only the current state. We preserve issue history by querying the journals and details tables directly via Redmine's database (MySQL or PostgreSQL) or REST API, extracting each journal entry with its author, timestamp, old_value, new_value, and notes, then appending them as Jira comments with a [Migrated from Redmine history] prefix and the original timestamp. This step requires direct database access or REST API enabled on Redmine. Jira's free tier comment limits apply; very large histories may require batching.
What happens to attachments during migration?
Redmine stores attachments on the filesystem, not in the database. We enumerate the /files directory during discovery, copy all files to a staging location, and re-upload each file to Jira via the REST API, linking it to the corresponding Issue key. This is a separate step from the database migration and can extend the timeline significantly for large attachment volumes. Files exceeding Jira Cloud's 32 MB limit per attachment are flagged for chunking or alternative handling. If the /files directory is inaccessible or missing files are found, we document the gap in the migration report.
Is Jira Cloud or Jira Data Center the right destination?
The choice depends on the customer's data residency requirements, desired update cadence, and existing Atlassian ecosystem. Jira Cloud offers automatic updates, no infrastructure management, Atlassian Access for SSO, and native backup. Jira Data Center (server) offers perpetual licensing, no cloud dependency, and performance for very large-scale deployments (over 10,000 users or 1 million issues), but Atlassian ended new server license sales in February 2024 and continues only Data Center with annual renewal. Redmine migrations to Jira Cloud require API token authentication and may hit Jira Cloud's rate limits on large imports; Jira Data Center supports bulk import tools that reduce API round-trips. We support both destinations.
How do you handle Redmine custom trackers to Jira Issue Types?
Redmine Trackers (Bug, Feature, Support, and any custom trackers) are enumerations that categorize Issues. We map each Tracker to a Jira Issue Type that we pre-create in the target project's Issue Type scheme before migration. During Issue migration, we assign the Tracker value to the mapped Jira Issue Type. Each Jira Issue Type can have its own workflow, screen, and field configuration, so we document the Tracker-to-Issue-Type mapping during scoping and apply it as part of the Jira project schema pre-configuration step.
Related migrations
Sources: official documentation
- Import data from a CSV file — Atlassian Support
- Link your object schema to a Jira project — Jira Service Management Data Center
- Importing data from CSV — Administering Jira applications Data Center
- Create work items using the CSV importer — Jira Cloud
- Map CSV data to Jira fields — Jira Cloud Support
- Jira Cloud Migration Assistant pre-migration checklist — Atlassian Support
Get a quote
Moving from Redmine to Jira?
Tell us roughly how many records and objects you have. We scope the mapping and the Jira setup with you, then send a quote.
Get a quote