Migrate from MediaWiki to XWiki: what moves and what you rebuild
If your MediaWiki site holds years of pages, templates, uploaded files and internal links, you need to know which of those survive a move to XWiki and which you will rebuild by hand. Page content and files can be brought across with the MediaWiki XML filter, then converted with the Filter Streams Converter. Wiki syntax conversion, user accounts, groups, permissions and templates need planned rework, because they do not carry over as a simple import. Treat the import as the start of the project, not the finish. The effort is not a one-day import. It scales with three things: how many templates you have, how heavily the site depends on MediaWiki extensions and their macros, and how much cleanup the content needs before it lands in a new system. A site with a small set of plain articles and few templates is a very different job from one where templates drive navigation, infoboxes and data tables. Ask anyone quoting the work to show how they counted templates and extension usage, and whether they sampled pages to estimate cleanup. Confirm the MediaWiki version and installed extensions with your own team before you scope. Most of the rework sits in the parts readers notice least until they break. Internal links use MediaWiki page naming, namespaces and redirects, and those need to resolve to the new XWiki page references after import. Templates are not generally reproduced as one-to-one equivalents, so each one needs a decision: rebuild it as an XWiki script or macro, simplify it into static content, or retire it. Plan a link check against the full page inventory, and do not rely on a sample. Access needs its own track. Accounts, groups and page rights in MediaWiki do not map automatically to XWiki spaces, groups and rights. Decide the target permission model first, including who administers spaces, which groups read and which edit, and how your directory identities will be used if you connect one. Then rebuild permissions and test them with real user roles before cutover. Keep a record of who had access to restricted content, because an import that exposes a page to the wrong group is a security incident, not a formatting fault. The Confluence Migrator Pro extension from XWiki SAS covers Confluence spaces, pages, users, groups and permissions. It does not apply to MediaWiki, so this path uses the MediaWiki XML filter and the Filter Streams Converter instead. Confirm with your XWiki implementer which versions of XWiki and the converter they will test against, and run a full test import on a copy of the data before you set a cutover date.
Which MediaWiki features map to XWiki and which need rebuilding
This table compares common MediaWiki elements with their XWiki equivalents and gives a migration note for each. Treat each note as a starting assumption: the importer is expected to carry over structural content, while templates, extension output and access rules need review or rebuilding. Confirm every conversion behavior in a test import on a copy of your site before you plan cutover.
| MediaWiki element | XWiki equivalent | Migration note |
|---|---|---|
| Pages and revisions | XWiki pages and document versions | Converted by the importer. Confirm that revision history and authorship carry over in a test import. |
| Namespaces | Spaces and nested spaces | Converted with manual review. Decide the target space layout before the import runs. |
| Categories | Tags or a category property on pages | Converted with manual review. Confirm how category membership is represented after import. |
| Templates | Pages reused through includes or macros | Converted with manual review. Do not assume full fidelity. Check rendered output page by page. |
| File uploads | Attachments on pages | Converted by the importer. Confirm file names, sizes and attachment versions in a test import. |
| Internal links | XWiki wiki links and page references | Converted with manual review. Validate every link after import, including redirects and links to files. |
| Users and groups | XWiki users and groups | Rebuilt by hand. Plan account recreation and confirm whether any credentials carry over. |
| Page protection | Rights on spaces and pages | Rebuilt by hand. Map each protection level to a rights model you have designed and approved. |
| Extensions and parser functions | XWiki macros and extension markup | Rebuilt by hand. Output from extensions and parser functions does not carry over with full fidelity. |
Documented import paths for MediaWiki content into XWiki
The documented route moves MediaWiki content through three stages: export, conversion and import through the filter stream importers. Each stage produces an artifact the next one reads, so checking every hand-off before moving on is what keeps a test import from becoming a cutover problem.
Export pages and attachments
The export runs on the MediaWiki side and produces the input for every later step. Decide which namespaces and page revisions are in scope, and include the uploaded files that those pages reference, because image and file links break when attachments are left behind. Record the MediaWiki version and the export options used, so a test run can be reproduced exactly. Confirm the export options against the MediaWiki documentation for your release before running it.
Convert the export with Filter Streams Converter
Filter Streams Converter reads the exported MediaWiki content and writes a filter stream that XWiki's importers can consume. Treat the converted output as a checkpoint: count pages, compare page titles and check that attachment references resolve to files in the package before importing anything. Confirm the converter's command options and accepted input formats against the official XWiki documentation before you test.
Import through the filter stream importers
The filter stream importers write the converted content into a target XWiki instance, creating pages, page history and attachments. Run the first import into a non-production instance that runs the XWiki version planned for production. Review the import log for skipped or failed pages, then compare sample pages against the source. Users, groups and rights are not carried over by this route, so plan them as a separate workstream.
Verify versions and command options
Exact command options, the MediaWiki versions this route supports and the XWiki version line you target all need confirmation before testing. Check them against the official XWiki documentation and the MediaWiki documentation for your release, not against older blog posts or forum threads. Write the confirmed values into the migration runbook with the date they were checked. Repeat the check if either side upgrades during the project, because supported combinations can change between releases.
Pin an official XWiki Docker image line
The official XWiki Docker images come in MySQL, PostgreSQL and MariaDB variants, each running on Tomcat, for amd64 and arm64v8. Choose the stable line, the LTS line or the intermediate LTS line, and pin the exact tag for that line, using 18.8.0 for stable, 17.10.14 for LTS and 18.4.7 for the intermediate LTS as the reference values. Exact tags keep test and production imports on the same version. Confirm current tags in the official image repository before deploying, because the lines are updated on their own schedule.
Rebuilding users, groups and page permissions in XWiki
Plan users, groups and rights as a separate workstream from content import. A MediaWiki XML export carries page text, revisions and attachments, but you should not assume that accounts, group memberships and rights arrive in XWiki in a form you can rely on. Treat the account and permission model as something you map on paper, recreate deliberately and then test with real users before cutover.
Start with an inventory of the MediaWiki side. List the user accounts that have edited or are expected to edit content, and list every group in use, including built-in groups such as sysop, bureaucrat and the anonymous and logged-in classes, along with any custom groups your site added through its configuration. For each group, record what it can actually do on your wiki, which namespaces or pages it touches and who owns it. Then decide, group by group, whether it becomes an XWiki group, a role on a space or a rule that does not need to exist at all. Avoid a one-to-one copy of every MediaWiki group, because many were created for MediaWiki-specific rights that have no direct XWiki equivalent.
Next decide where each permission should live. In XWiki, rights can be granted at the wiki, space or page level, and lower levels can inherit from higher ones unless you override them. Set broad read and edit rights on spaces that match your team structure, and reserve page-level rights for the small number of pages that genuinely need different treatment, such as restricted HR or finance pages. Each page-level override is a maintenance cost, so keep a short written register of them. Confirm the exact right names, inheritance behavior and any administrator-only rights against the XWiki version you are deploying, using its administration documentation rather than memory of an older release.
Identity is the other decision. Existing MediaWiki passwords are generally not something you should migrate directly, so decide early whether XWiki accounts will be local, or whether sign-in will be delegated. If you want XWiki users to authenticate against an existing provider, the xwiki-contrib OpenID Connect extension (xwiki-contrib/oidc) can authenticate XWiki users against an external OpenID Connect provider, and it can also make XWiki act as a provider itself. Check its compatibility with the XWiki version you select, test it with a non-production account set and confirm how it maps identity claims to XWiki users and groups. Active Directory and Azure Active Directory SSO are offered as applications in XWiki Pro, which is a separate paid product choice. Confirm with XWiki SAS whether that product fits your environment, licensing and support model before you assume it is part of the plan.
Finish with a validation pass. Create a test set of accounts and groups, sign in as representative users from each group, and check read, edit, comment and administrative actions on sample pages in each space. Record the results against your permission register, fix mismatches, and repeat the check after the final import. Include orphaned edits and former accounts in the review so that attribution questions do not surface after go-live. Document who owns group membership changes after cutover, because the access model is only as good as the process that maintains it.
How to migrate from MediaWiki to XWiki in stages
This sequence moves MediaWiki content into XWiki in controlled stages, starting from an inventory and ending with a verified cutover. Each stage produces a signed-off output that the next stage depends on.
Inventory namespaces, templates, extensions and users
Your team, with input from content owners, lists every namespace, template, extension and user account in the MediaWiki site, and notes which ones are still in use. This tells you what the XML export must cover and which MediaWiki extensions have no XWiki equivalent, so each one needs a replacement or a decision to retire it. The output is a signed-off inventory with a named owner for each space. The step is done when every namespace has an owner and every extension has a keep, replace or retire decision.
Run a scoped pilot import
The migration engineer exports a representative set of pages and files with the MediaWiki XML export, then runs them through the Filter Streams Converter and an import into a non-production XWiki instance. Choose pages that include templates, categories, images, redirects and long edit histories, so the pilot exposes the problems that matter early. The output is an import log and a list of pages that failed or converted unexpectedly. The step is done when the pilot pages open in XWiki and the team agrees what each failure means.
Review syntax and links
Content owners and the migration engineer compare converted pages against the originals. They focus on MediaWiki markup that does not map cleanly to XWiki syntax, template calls, internal links, category tags and uploaded file references. Plan for manual cleanup on some pages, and allow time for content owners to review, not only engineers. The output is a cleanup backlog with an owner for each page type and a link check report. The step is done when internal links and file references resolve in the pilot and every backlog item has an owner.
Rebuild permissions for users and groups
The identity team and XWiki administrators recreate groups and access rules from the inventory, because MediaWiki group rights must be mapped to XWiki groups and spaces by hand. Decide which spaces are restricted and confirm how user accounts will authenticate in the target. The output is a permissions map signed off by content owners. The step is done when test accounts in each group see exactly the spaces the map allows and no others.
Run the parallel period
Both wikis stay readable while teams begin working in XWiki for an agreed period. Before the run starts, content owners decide whether edits on MediaWiki are frozen for each space or synced to XWiki, and the sync direction and conflict rules are written down. Confirm the length of the parallel run and the sync rules with your content owners, and do not assume a duration. The output is a running record of discrepancies and how each was resolved. The step is done when content owners sign off each space and no unresolved differences remain.
Cut over and retire the MediaWiki instance
Freeze edits on MediaWiki, run a final import of changes made during the parallel period, and update links and bookmarks that still point to the old site. Set the old site to read-only, then take a backup of its database, files and configuration under your records retention policy. Decommission the server only after a test restore of that backup succeeds. The output is a cutover record, a tested backup and a retirement note. The step is done when the old instance is read-only, the backup restores, and content owners confirm XWiki is the system of record.
What drives the cost and duration of a MediaWiki to XWiki move
This table lists the effort drivers that move cost and duration in a MediaWiki to XWiki migration, with whether each one is paid once or recurs and which way it pushes the budget. Use it to scope the work before requesting a quote. The XWiki SAS rates in the last row give a vendor comparison point, and DeployOpen quotes follow from a written scope.
| Driver | Effect on cost or duration | One-time or recurring | How to keep it down |
|---|---|---|---|
| Pages and revisions to convert | More pages and revisions lengthen export, filter stream conversion and link checking. | One-time | Archive stale spaces and delete test pages before export. |
| Templates and parser functions | Each template and parser function needs an XWiki equivalent or a rewrite. | One-time | Inventory templates first and retire the ones nobody uses. |
| Extension-generated content | Output from MediaWiki extensions may not convert cleanly and may need custom macros or manual rebuilding. | One-time | List installed extensions and sample their output before scoping. |
| Attachment volume | Larger file sets lengthen transfer and validation and increase storage sizing. | One-time for import, recurring for storage | Export only files referenced by live pages. |
| Users, groups and permissions | Each user, group and page restriction must be mapped to XWiki rights by hand or script. | One-time | Remove dormant accounts and agree the group model before the first import. |
| Identity integration scope | Connecting XWiki to a directory or OpenID Connect provider adds configuration, testing and access review work. | One-time build, recurring access reviews | Choose the identity source before test imports and confirm extension fit with your provider. |
| Hosting choice and XWiki line | Self-hosting adds platform, backup and upgrade work, and the chosen line sets the upgrade path you maintain. | Recurring | Confirm the current stable or LTS tag and database variant before building. |
| Depth of parallel run | Running MediaWiki and XWiki side by side extends content synchronization, editor training and cutover checks. | One-time, plus ongoing staff time | Set a short written freeze window and name one cutover owner. |
| Vendor consulting rate | XWiki SAS lists consulting at 1200 EUR per day (Business or Enterprise support plan required) and training at 1500 EUR per day. | Depends on scope | Ask for scope, days and deliverables in writing so quotes can be compared. |
Validating links and syntax after the import
The validation work after a MediaWiki import answers three questions before any user is switched over: are the pages all there, do the links still lead somewhere, and does the converted syntax still render the way content owners expect. Treat these as separate checks with separate evidence, because a clean page count can hide broken internal references, and a clean link crawl can hide tables that collapsed into plain text. Start with inventory. Compare page counts and attachment counts per space between the MediaWiki XML export and the XWiki target, using the same namespace-to-space mapping you agreed during the test import. Mismatches usually come from pages skipped by the export, redirects handled differently from articles, or files whose names were altered during import. Record each difference and its cause. Do not accept a total that matches only because one space gained pages and another lost them. Next, crawl internal links. The key point is that link rewriting depends on how the source links were formed. Links written with a plain page title, links that use namespace prefixes, links to files, and links built from templates or external links behave differently in the filter and converter. Do not assume the importer rewrote them correctly. Run a test import, crawl the result for broken references, and confirm for each link form in your own wiki whether it resolved, pointed at the wrong space, or stayed as the original text. Templates that generate links deserve their own check, since the generated output can change even when the stored source looks unchanged. Spot-check converted syntax by hand. Sample tables with merged cells, images with sizes and captions, heading hierarchies, and any macros or parser functions your MediaWiki pages used. Compare each sample with the source rendering side by side. Templates whose output changed should be reviewed as a group, with the content owner confirming that the new output still says what the page is meant to say. Syntax gaps are expected for some constructs, so the goal is an agreed list of accepted differences, not zero differences. Sign-off belongs to the wiki owner for content accuracy, with the platform team confirming the technical checks. Content owners should receive, for each space they maintain, the count reconciliation, the list of broken or rewritten links with their resolution, the reviewed template list, and a sign-off record. Ask your partner or internal team to define these evidence items in the written scope before the test import, so cutover is decided against an agreed standard rather than a general impression.
What usually goes wrong in a MediaWiki to XWiki move and how to prevent it
Most problems in a MediaWiki to XWiki move trace back to a few decisions made early: which content is converted, who can see it, and when the old wiki stops taking edits. Each risk below is paired with one prevention step tied to the migration sequence, so the team can check it before cutover rather than after users report it.
Templates that render differently
MediaWiki templates, parser functions and extension tags do not map one to one onto XWiki macros, so a page can look correct in the export and break after import. Pages that depend heavily on templates, infoboxes or navigation boxes are the most likely to change. Prevention: convert a representative pilot set that includes the most template-heavy pages, then compare rendered output against the original by hand before approving the full run.
Broken links and missing files
Internal links use MediaWiki title rules, and attachments referenced by pages must be exported alongside the XML. A missing file or a link that points to a renamed page will show as a red link to readers. Prevention: after the import, run a link check across all converted spaces and compare the attachment count against the source, then fix or document each exception before the cutover date is set.
Permissions that open or lock too much
MediaWiki group rights rarely translate directly into XWiki rights on spaces and pages, so copied access models can expose restricted content or lock editors out of their own spaces. Both errors are easy to miss because the pages still import successfully. Prevention: review permissions space by space against a written list of who should read and who should edit, and test with one account from each role before any user is invited.
Duplicate or orphaned user accounts
Accounts that exist in MediaWiki under several names, or that belong to former staff, can be imported as duplicates or as accounts with no owner. Attribution on edits and group memberships then point to the wrong person. Prevention: reconcile the user list with the identity source before import, decide how each old account maps to a new one, and retire unmapped accounts explicitly rather than leaving them active.
Edits lost during the parallel run
If people keep editing the MediaWiki site while the XWiki copy is being checked, those edits will not appear in XWiki unless someone reimports them. Teams often discover this only after the old site is switched off. Prevention: set a frozen edit window for the final import, announce it in advance, and keep the MediaWiki instance in read-only mode with a rollback plan that restores editing there if the cutover fails.
Underestimating manual cleanup
Conversion handles the bulk of content, but syntax gaps, abandoned drafts, duplicate pages and outdated categories remain for people to review. Teams that plan only for the import run usually find that review takes longer than the conversion itself. Prevention: count the pages that the pilot flagged for manual work, assign owners by space, and ask the partner for a written cleanup estimate based on that pilot sample rather than the full site.
Questions buyers ask before moving MediaWiki to XWiki
How much does a MediaWiki to XWiki migration cost?
The cost depends on scope, not on a standard package. The main drivers are the number of pages and namespaces, how many templates, parser functions and extensions your wiki uses, the volume of attachments, how many users and permission rules must be rebuilt, and how much syntax cleanup your content owners expect. Migration work is one-time. XWiki hosting, support and any extensions recur. For reference, XWiki SAS lists consulting at 1200 EUR per day, which requires a Business or Enterprise support plan, and training at 1500 EUR per day. These are XWiki SAS list rates, not DeployOpen prices. Ask for a written quote with line items for inventory, export, test imports, syntax review, permission rebuild, link validation, cutover and handover, plus any assumptions about page volume and custom extensions.
How long does it take to migrate a MediaWiki site into XWiki?
Duration follows the amount of content to check and the number of decisions your team must make. In general terms, the work moves through an inventory of pages and extensions, an export, one or more test imports, a review of converted syntax, a rebuild of users and permissions, link validation and a cutover. Each test import usually reveals conversion gaps that need a decision, so the number of review cycles matters as much as the number of pages. No figure is given here because durations vary too much between sites. Ask for a scoped plan that states phases, dependencies, reviewer time and the sign-off points, and treat any duration without that plan as a generic estimate.
What must our internal team provide during a MediaWiki migration?
Your team supplies decisions, access and sign-off. Content owners decide which spaces, pages and history to keep, archive or drop, and they review converted pages for meaning and layout. Identity administrators provide the user directory or account source and approve how groups map to XWiki groups and rights. Hosting administrators provide the target environment, backup access and network paths for the import. Someone must also own the sign-off on link checks and syntax checks before cutover. Ask the partner to name each role, the hours expected from each person, and the point at which each approval is required, so that delays are visible in the plan rather than discovered at cutover.
Can our own team migrate MediaWiki to XWiki without outside help?
Yes, a team with the right skills can run the migration with the documented tools. The path uses a MediaWiki XML export of pages and files, which is then processed with the Filter Streams Converter and imported into XWiki. Your team must be comfortable with the MediaWiki database and export options, XWiki administration, scripting for repetitive fixes and structured validation. The hard part is rarely the first import. It is deciding how each template, extension tag and internal link pattern should look in XWiki, and rebuilding permissions correctly. Before deciding, run a small test import of representative pages and count how many conversion decisions it produces.
Does the Confluence Migrator Pro extension apply to a MediaWiki migration?
No. Confluence Migrator Pro applies only to Confluence. XWiki SAS describes it as migrating Confluence spaces, pages, users, groups, permissions, attachments and metadata, keeping page history but not attachment history. It is priced from 2000 EUR, and its trial is limited to 30 pages per migration. None of these terms apply to MediaWiki content. A MediaWiki move uses the MediaWiki XML export and the Filter Streams Converter path described in the migration guidance, so budget and plan for that path separately. Confirm the current licensing and trial terms with XWiki SAS before relying on any figure for a Confluence project.
Which MediaWiki syntax and features are likely to need manual cleanup?
Expect manual work wherever MediaWiki relies on templates, parser functions, extension tags or site-specific conventions. Typical areas that need review include template calls and their parameters, parser functions, tag-based extensions, category and namespace conventions, internal link forms, embedded and linked files, and tables with complex markup. Build a list of these constructs by searching your export before the first test import, then import a sample that includes each construct. Record which pages convert cleanly, which convert with loss and which need rewriting. Ask the partner to confirm the conversion results on your sample set, since behavior depends on the MediaWiki version and extensions you run.
How do we validate links and content after the MediaWiki import?
Validation combines automated checks with reviewer sign-off. Start by comparing page counts, namespace counts, attachment counts and revision handling between the source and the target. Crawl internal links in XWiki and list every broken or changed target, including redirects that did not carry over. Sample pages in each space and check that permissions match the rules agreed with identity administrators. Content owners then review the sampled pages and the flagged list before approving cutover. Agree on the acceptance criteria in writing before the import, including what counts as an acceptable number of open issues, so the sign-off is not left to judgment at the last minute.
How DeployOpen works on this
DeployOpen treats a MediaWiki to XWiki move as a planned migration inside infrastructure you control, not a file copy. The work starts with a written scope that covers which spaces, pages, files, users and permissions move, and it ends with a documented, validated XWiki instance your team can run.
How we scope
- Inventory the MediaWiki namespaces, page counts, file types, templates and extensions that the migration must account for
- Agree in writing which content moves, which is archived and which is retired before any export runs
- Define the XWiki target: edition, database variant, hosting location and the user directory it will authenticate against
- Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts
How we build
- Export pages and files from the MediaWiki source and run the MediaWiki XML filter through the Filter Streams Converter in a test environment
- Log every syntax construct that does not convert cleanly and agree a remediation approach for each category with your content owners
- Rebuild groups, users and page rights in XWiki from the access model you approved, not from a raw copy of the old wiki
- Run repeated test imports and check internal links, attachments and templates against a documented list before cutover
How we hand over
- Document the export, conversion, import and cutover steps so the migration can be repeated or audited by your team
- Provide the link validation results, known conversion gaps and the list of content left for manual cleanup
- Deliver runbooks for XWiki installation, backups, upgrades and extension management in your environment
- Walk your administrators through permissions, space structure and day-to-day operation before the handover is closed
How we support
- Agree a post-cutover support window in the written scope, covering fixes to imported content and access issues
- Ongoing support, upgrades and continuous testing are available as a DeployOpen retainer after handover
- Plan XWiki version upgrades, including the choice between the stable line and an LTS line, as a separate, scoped piece of work
- Confirm with XWiki SAS which professional support plan your organization needs for vendor-backed help alongside DeployOpen

