How to Migrate from Confluence to Outline 2026
How to Migrate from Confluence to Outline 2026
Outline has a native Confluence importer — making it the easiest Confluence migration path among open source wiki tools. Export your Confluence spaces, upload to Outline, and your pages transfer with formatting intact. Confluence Standard costs $61/month for 10 users. Outline self-hosted is free.
TL;DR
Export Confluence spaces as HTML or XML ZIP files, import them through Outline's built-in Confluence importer, organize the imported documents into collections, and configure SSO. Most content transfers cleanly — macros need manual attention. The migration is measurably faster than other Confluence alternatives because of the native import support.
Key Takeaways
- Outline's Confluence importer handles pages, hierarchy, images, tables, code blocks, and internal links
- Macros (Jira links, draw.io, expand, etc.) need manual cleanup after import
- Comments and page history are not preserved
- Outline requires an auth provider (OIDC, Google, Slack) — it has no built-in email/password
- Self-hosting requires: PostgreSQL, Redis, S3-compatible storage (MinIO), and an auth provider
- For large Confluence instances (1000+ pages), export and import space by space
Why Teams Leave Confluence
Confluence's pricing has increased significantly since Atlassian moved to cloud-only pricing. The Standard cloud plan costs $6.05/user/month — that's $728/year for a 10-person team. Premium is $11.55/user/month. With Atlassian's regular price increases, multi-year total cost of ownership is a concern.
Beyond cost, Confluence suffers from feature bloat accumulated over two decades. The editor is slow, the macro system is opaque to non-technical users, and searching for specific content requires knowing Confluence's search syntax. Teams using Confluence primarily for documentation find that Outline's editor (based on ProseMirror) is significantly faster and more intuitive.
For teams already using BookStack as their wiki, Outline offers a more polished editor experience. The tradeoff: BookStack has email/password auth built in, while Outline requires an external auth provider. See the Notion, AppFlowy, Affine, and Obsidian comparison for a broader look at knowledge management tools.
What Transfers
| Content | Status |
|---|---|
| ✅ Pages and hierarchy | Native import |
| ✅ Text formatting | Well preserved |
| ✅ Images | Imported |
| ✅ Tables | Supported |
| ✅ Code blocks | Supported |
| ✅ Links between pages | Internal links mapped |
| ⚠️ Macros | Some need manual cleanup |
| ⚠️ Attachments | Most import, large files may need re-upload |
| ❌ Comments | Not preserved |
| ❌ Page history/versions | Not preserved |
Step 1: Export from Confluence
- Go to your Confluence space → Space Settings
- Click Content Tools → Export
- Select HTML export format (better compatibility than XML for Outline's importer)
- Choose Full Export (includes all pages and attachments)
- Download the ZIP file
Repeat for each space you want to migrate. For large spaces (500+ pages), the export may take several minutes and produce a large ZIP file. Confluence's export rate-limits concurrent exports — run one export at a time.
If your Confluence instance is self-hosted (Confluence Data Center/Server), access the Space Settings directly as an admin. Cloud exports are identical in format.
Step 2: Deploy Outline
git clone https://github.com/outline/outline.git
cd outline/docker
cp .env.sample .env
Edit .env with your configuration:
# Required
SECRET_KEY=generate-with-openssl-rand-hex-32
UTILS_SECRET=generate-with-openssl-rand-hex-32
DATABASE_URL=postgres://outline:password@db:5432/outline
REDIS_URL=redis://redis:6379
URL=https://wiki.yourdomain.com
# Auth provider (choose one)
GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-client-secret
# Storage (S3 or compatible)
AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret
AWS_REGION=us-east-1
AWS_S3_UPLOAD_BUCKET_URL=https://s3.yourdomain.com
AWS_S3_UPLOAD_BUCKET_NAME=outline
Then start the services:
docker compose up -d
Auth provider options:
- Google Workspace (easiest for G Suite teams)
- Slack (popular for dev teams)
- OIDC (generic: Keycloak, Authentik, Azure AD, Okta)
- GitHub (for developer-focused teams)
Outline does not have built-in username/password authentication. You must configure at least one OAuth or OIDC provider. For teams without a Google or Slack account, set up Authentik or Keycloak as the OIDC provider.
Storage (for images and attachments): Outline requires S3-compatible storage for file uploads. Use MinIO for self-hosted S3 storage:
# MinIO in docker-compose.yml
minio:
image: minio/minio
command: server /data
environment:
MINIO_ROOT_USER: admin
MINIO_ROOT_PASSWORD: password
volumes:
- minio-data:/data
Requirements: PostgreSQL, Redis, S3-compatible storage (MinIO or AWS/Cloudflare R2), auth provider (OIDC/Google/Slack).
Step 3: Import via Native Importer
- Open Outline → Settings → Import
- Select Confluence as the source
- Upload the exported ZIP file
- Outline processes the export and creates documents
Pages maintain their hierarchy as nested documents within a collection. The importer runs asynchronously — for large imports (1000+ pages), it may take 5-15 minutes to process. The import status is visible in the Settings → Import section.
After import completes, verify the results:
- Check that page hierarchy matches Confluence's space structure
- Verify that images display correctly
- Test internal page links
- Note which macros need manual cleanup
Step 4: Organize Collections
Map Confluence spaces to Outline collections:
| Confluence | Outline |
|---|---|
| Space | Collection |
| Page tree root | Top-level documents |
| Child pages | Nested documents |
| Labels | Tags (manual) |
| Templates | Document templates |
Each imported Confluence space becomes a collection in Outline. You can rename collections, set icons, and adjust membership permissions after import. If you merge multiple small Confluence spaces into one Outline collection, do this after import by moving documents between collections.
Step 5: Set Up Auth and Permissions
Configure OIDC for enterprise SSO (Keycloak, Authentik, Google):
OIDC_CLIENT_ID=outline
OIDC_CLIENT_SECRET=your-secret
OIDC_AUTH_URI=https://auth.yourdomain.com/authorize
OIDC_TOKEN_URI=https://auth.yourdomain.com/token
OIDC_USERINFO_URI=https://auth.yourdomain.com/userinfo
OIDC_DISPLAY_NAME=Company SSO
OIDC_SCOPES=openid profile email
Set collection-level permissions:
- View only — for company-wide documentation that users shouldn't edit
- Editor — for team-specific documentation
- Manager — for collection owners who can change membership
Outline's permission model is simpler than Confluence's space-level and page-level permissions. If you had complex Confluence permission hierarchies, plan to simplify them in Outline — the tool is designed for more open internal documentation.
Step 6: Handle Confluence Macros
| Confluence Macro | Outline Handling |
|---|---|
| Code block | ✅ Preserved |
| Info/Note/Warning | Convert to blockquote or callout |
| Table of contents | Auto-generated sidebar |
| Jira links | Convert to plain URLs or text |
| Page include | Link to document instead |
| Draw.io | Export as image, embed |
| Expand | Not supported (flatten content) |
| Page properties | Use document properties instead |
| Attachments | Files need manual re-upload |
Macro cleanup is the most time-consuming part of the migration. For large Confluence instances, prioritize pages that are actively used — legacy pages with complex macros may not be worth the cleanup effort.
Step 7: Configure Outline's Features
After migration, configure Outline's features that add value beyond what Confluence offers:
Real-time collaboration: Multiple users can edit the same document simultaneously. Outline uses operational transformation — no "edit locks" or "draft" modes required.
Full-text search: Outline's search uses PostgreSQL full-text search and returns results quickly even across thousands of documents. No need to learn special search operators.
Document templates: Create templates for meeting notes, project briefs, and incident reports. New documents can be created from templates by any team member.
Guest access: Share individual documents with external guests (clients, contractors) who can view or comment without full team access.
Cost Savings
| Team Size | Confluence Standard | Outline Self-Hosted | Savings |
|---|---|---|---|
| 10 users | $61/month | $15/month (VPS) | $552/year |
| 25 users | $152/month | $20/month | $1,584/year |
| 50 users | $302/month | $35/month | $3,204/year |
| 100 users | $578/month | $50/month | $6,336/year |
VPS costs include the Outline application, PostgreSQL, Redis, and MinIO.
Migration Timeline
| Week | Task |
|---|---|
| Week 1 | Deploy Outline, configure auth and storage, import Confluence spaces |
| Week 2 | Clean up macros, organize collections, set permissions |
| Week 3 | Invite team, run both platforms in parallel |
| Week 4 | Announce cutover, make Outline the primary documentation tool |
Why Replace Confluence?
Confluence started as a straightforward enterprise wiki and became the default documentation tool for teams using Jira. Over the past several years, Atlassian's pricing structure has shifted significantly. Confluence Cloud Standard costs $5.75 per user per month for smaller teams, with Premium at $11 per user per month. A 50-person team on Standard pays $287.50 per month, or $3,450 per year just for documentation. The 2023 Atlassian price increases, which raised Cloud prices by 10-15% and eliminated the Server license option entirely, pushed many teams to evaluate alternatives. Teams that had relied on Confluence Server (a one-time license) were forced to either migrate to Cloud (and accept ongoing subscription fees) or find an alternative.
The complexity problem is equally significant. Confluence is widely described as a wiki that becomes unusable at scale. Spaces accumulate, permissions become tangled, nested macros slow page loads, and the search produces inconsistent results. Teams with more than a few hundred pages often find that Confluence's navigation becomes impenetrable — nobody can find anything, so nobody trusts the documentation, so nobody updates it. The platform becomes a graveyard of outdated content.
Outline takes the opposite approach. It is fast, clean, and markdown-native with a ProseMirror editor that renders formatting in real time. The search is powered by PostgreSQL full-text search and returns accurate results quickly even across thousands of documents. The document editor is genuinely pleasant to use — a significant improvement over Confluence's editor, which has historically been slow to respond and prone to lost work during autosave delays. Real-time collaborative editing works without the "someone is editing this page" lock that Confluence imposed.
Feature overlap between Confluence and Outline is high for core documentation use cases: nested page hierarchies, rich text editing, images, tables, code blocks, and internal links. Outline does not have Jira integration macros, inline tasks linked to project tickets, or the broad macro ecosystem that Confluence offers. For teams that primarily use Confluence as a wiki and meeting notes repository, Outline provides a meaningfully better editing experience at a fraction of the cost. See the best open source alternatives to Confluence 2026 for a comparison that includes BookStack, Docmost, and AppFlowy.
Understanding Outline's Structure
Outline organizes documents in a hierarchy that maps closely to Confluence but uses different terminology. Understanding this mapping before the import makes migration easier to plan.
Collections in Outline correspond to Confluence Spaces. A collection is a top-level grouping with its own access controls, description, and icon. You can make a collection visible to all workspace members, restrict it to specific groups, or make it private. Each imported Confluence space becomes one Outline collection. After import, you can rename collections and adjust permissions to match your team's access requirements.
Documents in Outline correspond to Confluence Pages. Outline documents support full nesting — a document can contain child documents, which can contain further children, to any depth. This directly mirrors Confluence's page tree. The document breadcrumb navigation shows the full path from collection through parent documents to the current document.
The search-first approach is the most significant philosophical difference from Confluence. Outline's search is fast enough and accurate enough to serve as the primary navigation method for documents not accessed daily. Confluence's hierarchical navigation was often the only reliable way to find a specific page because Confluence's search was inconsistent. In Outline, teams naturally shift toward typing search terms rather than clicking through the document tree. This mirrors how people use modern tools and reduces the cognitive overhead of remembering exactly where a document lives in the hierarchy.
Outline does not have a built-in page history view showing individual word-level diffs across versions like Confluence's version history. Outline tracks document revisions and allows restoring previous versions, but the comparison view is less granular. For teams that relied on Confluence's revision history for compliance auditing, this is a meaningful limitation to consider.
Migrating Content from Confluence
Outline's native Confluence importer is the primary migration path and produces good results for text-heavy documentation. Begin in Confluence: navigate to your space, open Space Settings, click Content Tools, then Export. Choose HTML export format over XML — the HTML export preserves formatting more reliably for Outline's importer. Select Full Export to include all child pages.
Content that imports cleanly includes headings and body text, basic formatting, code blocks, tables, bulleted and numbered lists, and images embedded directly in pages. Internal links between pages in the same export are remapped to Outline document links automatically.
Content that requires manual cleanup falls into several categories. Confluence macros are the biggest cleanup task. Info, Note, and Warning macros (colored callout boxes) become raw macro code in the imported document — convert these to Outline's callout block format manually. Page-include macros become broken references — replace each with a regular document link. Jira ticket macros become dead links — decide whether to remove them, replace with plain text references, or convert to regular URLs. Complex tables created with Confluence's table macro sometimes import with incorrect column widths or merged cell issues in actively used documents.
For spaces with hundreds or thousands of pages, prioritize cleanup. Sort documents by last-modified date in Confluence before exporting. Pages not modified in over a year are likely outdated — consider archiving rather than migrating them. Focus cleanup effort on documentation actively referenced by your team.
Setting Up SSO and Team Access
Outline does not support username and password authentication. Every user authenticates via an OAuth2 or OIDC provider. This simplifies user management (no passwords to reset, no credential compromise risk) but requires planning before deployment. The supported providers are Google Workspace, Slack, GitHub, GitLab, and any OIDC-compatible provider.
For teams already using Google Workspace, the Google OAuth integration is the fastest path — create OAuth credentials in Google Cloud Console and add the environment variables to Outline's configuration. All users in your Google Workspace domain can sign in immediately.
For self-hosted SSO, Keycloak and Authentik are the two most popular OIDC providers that integrate cleanly with Outline. Configure the OIDC environment variables in Outline's Docker Compose file with the provider's authorization, token, and userinfo endpoints. Outline reads the user's email and display name from the OIDC userinfo response to create the account on first login. Set the OIDC scopes to include "openid email profile" to ensure Outline receives all required user attributes.
Collection access in Outline is configured per collection. After import, navigate to each collection's settings and configure who can access it — all workspace members, specific groups, or explicitly invited members. Setting up groups in Outline before importing and assigning users to groups allows you to configure collection permissions systematically. For teams considering BookStack as an alternative with simpler authentication requirements, the how to migrate from Confluence to BookStack 2026 guide covers an option that includes built-in email/password login alongside SSO.
For a broader comparison of Outline against other documentation-first tools, see the AppFlowy vs Outline 2026 comparison, which covers the trade-offs between Outline's documentation focus and AppFlowy's all-in-one workspace approach for teams that want databases and kanban boards alongside their wiki.
Common Pitfalls
Confluence macros don't migrate: The biggest source of post-import cleanup work is Confluence macros. Jira ticket embeds, status badges, info panels, warning boxes, code snippet macros, and page-include macros all require manual attention after import. Build cleanup time into your migration timeline — for a Confluence instance with hundreds of pages that heavily use macros, this can take days.
Image hosting differences: Confluence serves images from Atlassian's CDN. After migration, Outline serves images from its configured S3 storage (MinIO or a cloud provider). Without properly configured S3 storage, image imports fail silently — the text imports correctly but images display as broken. Verify S3 connectivity and correct bucket permissions before running the import. Test by uploading a test image through the Outline UI before importing any content.
Search behavior differences: Outline's search finds documents based on title and body text content. Confluence's search indexing includes page properties, labels, and metadata that Outline does not index. Teams accustomed to searching by Confluence labels or page properties need to adjust their search approach. Use Outline's collection and document hierarchy as an additional navigation path alongside search.
Lack of page versioning display in Outline UI: Outline stores document revisions, but it does not provide a Confluence-style diff view showing exactly what changed between versions. For compliance-heavy documentation that requires tracked change histories, this is a gap. Consider supplementing Outline with a document export or webhook integration that logs document changes to an external audit trail.
Auth provider required: Outline has no built-in username/password login. If your team doesn't use Google, Slack, or another supported provider, set up Keycloak or Authentik as an OIDC provider before inviting users. Don't deploy Outline without testing the auth flow end-to-end first.
S3 storage for images: Images in imported documents are stored in Outline's S3 bucket. Without properly configured S3 storage, image imports fail silently — the text imports correctly but images display as broken. Verify S3 connectivity before running the import.
Large space exports: Confluence export ZIPs for large spaces can be 5-20 GB. Outline's importer handles large files, but the process takes time. Run imports during off-peak hours and verify the import log for any errors.
Post-Migration: Maximizing Outline's Capabilities
Once the migration is complete and your team is using Outline as the primary documentation tool, there are several ways to get more value from the platform that go beyond Confluence's capabilities.
The document sidebar and nested structure in Outline encourages a more organized approach to documentation than Confluence's flat page approach. Take time during and after the migration to rationalize the document hierarchy. Many Confluence instances accumulate years of abandoned pages, orphaned spaces, and outdated documentation that nobody reads but everyone is afraid to delete. The migration is the right time to archive or delete content that is no longer relevant, leaving a cleaner, more navigable documentation structure in Outline.
Outline's public sharing feature allows individual documents or collections to be shared with a public URL that anyone can view without authentication. This is useful for documentation that should be accessible to customers, partners, or contractors without creating user accounts. Public-facing runbooks, onboarding guides, or public API documentation can live in Outline with a shared URL, without requiring a separate public documentation site.
The integration between Outline and your team's other tools deepens its utility. Outline provides webhooks for document create, update, and delete events, enabling you to build automations — for example, posting a Slack notification when a specific collection's documents are updated, or syncing document titles to a project management tool. The REST API allows reading and writing documents programmatically, which supports use cases like automatically generating postmortem documents when a monitoring alert fires.
For teams evaluating whether Outline's feature set is sufficient for their documentation needs, consider the document maturity model. Outline excels at living documentation that teams actively update — technical runbooks, product specs, meeting notes, decision records. It is less suited for static reference documentation that benefits from versioning and formal publication workflows. If your team needs versioned documentation with structured review processes, tools like BookStack or a static site generator may be more appropriate complements to Outline for specific documentation types.
Comparing Outline to Other Confluence Alternatives
Outline is not the only strong open source Confluence replacement. The choice between tools depends on your team's specific needs and technical environment.
BookStack takes a simpler approach than Outline, with built-in email/password authentication and a book → chapter → page hierarchy that maps intuitively to structured documentation. The Docmost vs Outline comparison covers a newer alternative that offers a simpler deployment model than Outline. For teams that want a comprehensive comparison before committing, the best open source note-taking and wiki tools guide covers the full landscape including Outline, BookStack, Docmost, AppFlowy, Obsidian, and others.
The AppFlowy vs Outline comparison is particularly useful for teams that want a more comprehensive workspace (AppFlowy includes databases, kanban boards, and calendar views alongside documents) versus a documentation-first tool (Outline). The trade-off is that AppFlowy's self-hosted deployment is more complex and its document editing is less mature.
For organizations considering a centralized identity approach alongside the documentation migration, configuring Keycloak or Authentik as the OIDC provider for Outline gives you single sign-on across multiple self-hosted tools simultaneously. The Keycloak vs Authentik comparison covers the deployment differences between the two most popular open source identity providers, helping you choose the right foundation for your self-hosted authentication layer.
The Bottom Line
Outline is the most frictionless Confluence replacement for teams that use a compatible auth provider. The native Confluence importer reduces the migration work significantly compared to manually recreating documentation. The editor is genuinely better than Confluence's, search is faster, and the self-hosting cost is a fraction of Confluence's per-user pricing.
Compare wiki platforms on OSSAlt — editing experience, import support, and self-hosting side by side.
See open source alternatives to Confluence on OSSAlt.