BookStack vs Wiki.js in 2026: Self-Hosted Documentation Platforms Compared

TL;DR

Both BookStack and Wiki.js are mature, self-hosted documentation platforms that replace Confluence and GitBook. BookStack imposes a structured hierarchy (Shelves → Books → Chapters → Pages) that helps organizations keep documentation organized — and runs on shared PHP hosting. Wiki.js provides maximum flexibility — multiple editor modes (WYSIWYG, Markdown, raw HTML), Git-based storage, powerful diagram support (Draw.io, Mermaid, PlantUML), and a GraphQL API. Choose BookStack for structured hierarchical docs; choose Wiki.js for flexibility and Git sync.

Key Takeaways

BookStack (MIT, 16K+ stars) uses PHP/Laravel with a four-level hierarchy — intuitive to navigate, runs on shared hosting without Docker
Wiki.js (AGPL-3.0, 25K+ stars) uses Node.js with pluggable storage (PostgreSQL, Git, local files), multiple editors, and extensive diagram support
GitBook's Pro plan costs $8/user/month — a 10-person documentation team pays $960/year
Confluence Data Center licensing has become expensive — both open source tools provide strong replacements
BookStack's hierarchy (4 levels) helps enforce documentation structure; Wiki.js is fully flat (folders)
Both support LDAP, SAML, and OAuth for enterprise authentication

The Documentation Platform Choice

Technical documentation has two failure modes: undiscoverable (the right content exists but no one can find it) and unstructured (a flat pile of pages with no hierarchy). These tools address both differently.

BookStack solves discoverability through enforced hierarchy. The structure (Shelves contain Books contain Chapters contain Pages) maps naturally to how organizations think about documentation: product areas contain feature guides contain specific topics. New team members know exactly where to look.

Wiki.js solves flexibility through a modular architecture. Choose your storage backend, choose your editor, choose your authentication. If your team's documentation should live in a Git repository (for version control alongside code), Wiki.js is the only mainstream option that supports this natively.

BookStack — Structured Documentation

BookStack is one of the most battle-tested self-hosted documentation tools available. The Laravel/PHP codebase is stable, well-maintained, and has a zero-drama operational record — no major security incidents, consistent releases.

# BookStack Docker Compose
services:
  bookstack:
    image: lscr.io/linuxserver/bookstack:latest
    restart: unless-stopped
    ports:
      - "6875:80"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - APP_URL=https://docs.yourdomain.com
      - DB_HOST=bookstack_db
      - DB_PORT=3306
      - DB_USER=bookstack
      - DB_PASS=password
      - DB_DATABASE=bookstackapp
      # Email configuration
      - MAIL_DRIVER=smtp
      - MAIL_HOST=smtp.yourdomain.com
      - MAIL_PORT=587
      - MAIL_ENCRYPTION=tls
      - MAIL_USERNAME=docs@yourdomain.com
      - MAIL_PASSWORD=smtp-password
      - MAIL_FROM=docs@yourdomain.com
    volumes:
      - bookstack_config:/config
    depends_on:
      - bookstack_db
  bookstack_db:
    image: lscr.io/linuxserver/mariadb:latest
    restart: unless-stopped
    environment:
      - PUID=1000
      - PGID=1000
      - MYSQL_ROOT_PASSWORD=rootpassword
      - MYSQL_DATABASE=bookstackapp
      - MYSQL_USER=bookstack
      - MYSQL_PASSWORD=password
    volumes:
      - bookstack_db_data:/config
volumes:
  bookstack_config:
  bookstack_db_data:

The four-level hierarchy is BookStack's organizing principle:

Shelves — top-level categories (e.g., "Engineering", "Product", "Company")
Books — major documentation areas (e.g., "API Reference", "Deployment Guide", "Employee Handbook")
Chapters — groups of related pages (e.g., "Authentication", "Rate Limits")
Pages — individual documentation pages

This structure enforces that every piece of documentation lives somewhere logical. The sidebar navigation shows the full hierarchy, making it easy to browse related content.

The WYSIWYG editor is mature and reliable. It handles tables, code blocks with syntax highlighting, images, lists, embeds, and drawing (built-in drawing canvas for simple diagrams). A Markdown editor is also available per-page for users who prefer it.

Page versioning tracks every edit with author information. Roll back to any previous version with one click. Compare two versions side by side to see what changed.

Export options make BookStack valuable for compliance and distribution:

PDF export (single page or entire book)
HTML export (for archiving or offline distribution)
Plain text export
Markdown export

REST API enables automation — create books, chapters, and pages programmatically:

# Create a page via API
curl -X POST https://docs.yourdomain.com/api/pages \
  -H "Authorization: Token user_id:token_secret" \
  -H "Content-Type: application/json" \
  -d '{
    "book_id": 42,
    "chapter_id": 8,
    "name": "Getting Started Guide",
    "markdown": "# Getting Started\n\nWelcome to the system..."
  }'

Enterprise authentication:

LDAP/Active Directory (username/password against LDAP)
SAML 2.0 (Okta, Azure AD, Authentik)
OAuth2 (Google, GitHub, any OIDC provider)
Email whitelist (only allow signups from your domain)

Key features:

Four-level hierarchy (Shelves → Books → Chapters → Pages)
WYSIWYG + Markdown editors
Page versioning with diff view
Full-text search
PDF/HTML/Markdown export
Drawing canvas (simple diagrams)
REST API
Webhook support
LDAP, SAML, OIDC, Google, GitHub auth
30+ interface languages
MIT license, 16K+ stars
Runs on shared PHP hosting (no Docker required)

Limitations:

No Git-based storage
Less flexible diagram support than Wiki.js (no Draw.io, no Mermaid natively)
PHP/MySQL stack (some teams prefer Node.js)
Hierarchy enforced at all times — can feel rigid for some documentation styles

Wiki.js — Maximum Flexibility

Wiki.js is built around a plugin architecture: almost every component is swappable. Storage backend, authentication, editor, search engine — all are plugins you configure.

# Wiki.js Docker Compose
services:
  db:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: wiki
      POSTGRES_USER: wikijs
      POSTGRES_PASSWORD: password
    volumes:
      - wiki_db:/var/lib/postgresql/data
  wiki:
    image: ghcr.io/requarks/wiki:2
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      DB_TYPE: postgres
      DB_HOST: db
      DB_PORT: 5432
      DB_USER: wikijs
      DB_PASS: password
      DB_NAME: wiki
    depends_on:
      - db
volumes:
  wiki_db:

Git sync is Wiki.js's most unique feature. Configure a Git repository (GitHub, GitLab, Gitea, any bare repo) as the storage backend. Every page save commits to Git. Every Git push syncs to Wiki.js. This means:

Documentation lives alongside your code in the same repository
Full Git history for every page (not just Wiki.js's own versioning)
Pull requests for documentation changes (code review for docs)
Branch-based staging environments for documentation updates
Export/import the entire wiki by cloning the repository

# Wiki.js admin → Storage → Git repository
# Configure in the admin UI:
storage:
  git:
    authType: ssh
    repoUrl: git@github.com:your-org/documentation.git
    branch: main
    sshPrivateKey: /path/to/deploy_key
    syncDirection: bi-directional  # Read + write from/to Git
    gitAuthorName: Wiki.js
    gitAuthorEmail: wikijs@yourdomain.com

Multiple editors accommodate different team preferences:

Visual Editor: Block-based WYSIWYG (similar to modern wiki editors)
Markdown Editor: Full Markdown with live preview
AsciiDoc: For technical documentation teams
Raw HTML: For maximum control

Diagram support is extensive:

Draw.io / Diagrams.net: Full-featured diagramming embedded in pages
Mermaid: Text-based diagrams (flowcharts, sequence, Gantt, ER)
PlantUML: UML diagrams from text definitions
Kroki: Additional diagram types (BlockDiag, Graphviz, Structurizr)

Elasticsearch-powered search provides near-instant full-text search across thousands of pages with relevance ranking. For smaller wikis, the built-in PostgreSQL full-text search is sufficient.

Key features:

Pluggable storage (PostgreSQL, Git, S3, Azure Blob, local)
Multiple editors (Visual, Markdown, AsciiDoc, HTML)
Git sync for documentation-as-code workflows
Draw.io, Mermaid, PlantUML diagram support
Elasticsearch search (optional, default: PostgreSQL FTS)
Page-level permissions (not just role-based)
GraphQL API
Full theming support
LDAP, SAML, OAuth2 (10+ providers)
Multi-language (locale detection)
AGPL-3.0 license, 25K+ stars

Limitations:

No PDF export (a notable gap for teams distributing printed documentation)
No built-in comments (BookStack has comments on pages)
No built-in drawing canvas (must use Draw.io plugin)
More complex configuration (plugin system requires setup)

Side-by-Side Comparison

Feature	BookStack	Wiki.js
License	MIT	AGPL-3.0
Stars	16K+	25K+
Stack	PHP/Laravel + MySQL	Node.js + PostgreSQL
Organization	Enforced hierarchy	Flexible folders
Git sync	❌	✅
Editors	WYSIWYG + Markdown	WYSIWYG, Markdown, AsciiDoc, HTML
Draw.io diagrams	❌	✅
Mermaid	❌	✅
PlantUML	❌	✅
Search engine	Built-in	PostgreSQL FTS or Elasticsearch
PDF export	✅	❌
Comments	✅	❌
Page-level permissions	❌ (role-based)	✅
API	REST	GraphQL
Shared PHP hosting	✅	❌
Min RAM	256 MB	512 MB

Decision Framework

Choose BookStack if:

Clear hierarchical documentation structure is valuable (SOPs, handbooks, technical guides)
PDF export is needed (printed documentation, compliance records)
Page comments enable useful feedback workflows
You want to run on shared PHP hosting without Docker
MIT license is important

Choose Wiki.js if:

Git sync stores documentation alongside code in version control
Multiple editor modes support different team preferences
Rich diagram support (Draw.io, Mermaid, PlantUML) is essential
Page-level permissions provide finer access control than roles
GraphQL API for programmatic access
You want a highly customizable platform

Cost Comparison

Solution	Annual Cost (10 users)
GitBook Team	$960/year
Confluence Cloud Standard	$726/year
Notion Plus	$960/year
BookStack self-hosted	$60–100/year
Wiki.js self-hosted	$60–120/year

Content Organization Philosophy: Books vs Wikis

The organizational model of a documentation tool shapes what content gets written and how easily it gets found. BookStack and Wiki.js make opposite bets here, and the consequences are not cosmetic.

BookStack's book metaphor is opinionated. You cannot create a page without placing it in a Book. You cannot create a Chapter without placing it in a Book. This constraint forces a decision at creation time: where does this content belong? For teams that have struggled with documentation becoming a flat pile of orphaned pages, the enforced hierarchy is genuinely valuable. It prevents the "I'll just create a page and organize it later" behavior that creates documentation debt. The hierarchy also creates natural navigation — a new team member opens the "Engineering" shelf, browses the "Deployment" book, and finds the "Staging Environment Setup" chapter without needing to know what search terms to use.

The cost of hierarchy is rigidity. If a page legitimately belongs to two books — for example, a security checklist that's relevant to both the Engineering and Compliance books — BookStack requires choosing one home. You can link between books, but the page lives in one place. Some content doesn't fit the hierarchy cleanly, and accommodating it requires judgment calls that create ongoing maintenance overhead as the documentation grows.

Wiki.js's flat folder structure (with optional nesting) is more flexible but also more fragile. Without hierarchy enforcement, wikis tend to sprawl. The Git sync feature partially compensates for this: if your wiki syncs to a Git repository, file system discipline (consistent folder naming, no orphan pages) provides some structure. The access control model, which is page-level rather than role-level, adds another dimension of flexibility — you can share specific pages publicly without exposing the entire knowledge base. For technical teams comfortable with file system metaphors, Wiki.js's model feels natural. For non-technical contributors (HR, legal, operations), the lack of enforced structure creates anxiety about where to put new content.

Migration from Confluence to BookStack or Wiki.js

Moving off Confluence is a top priority for many teams following Atlassian's pricing changes. Both BookStack and Wiki.js provide migration paths, with different tradeoffs.

Confluence exports to XML (the standard export format). BookStack doesn't have a native Confluence XML importer, which means migration requires an intermediate step: convert the Confluence XML export to BookStack's expected format using community-maintained scripts (several exist on GitHub). The conversion handles page content (XHTML → BookStack HTML) and the space/page hierarchy (Confluence spaces become BookStack books). Attachments require separate handling — they're exported in a ZIP alongside the XML, and the migration script needs to re-attach them. Tables, code blocks, and basic formatting usually survive conversion cleanly. Confluence macros (Jira issue lists, page includes, status indicators) do not — they require manual replacement. For medium-sized Confluence instances (a few hundred pages), expect the migration to take one to two days of focused work. See How to Migrate from Confluence to BookStack 2026 for a complete walkthrough.

Wiki.js provides a Confluence import module in the admin interface, which directly accepts the Confluence XML export file. The importer creates pages and folders in Wiki.js matching the Confluence space structure. The same macro-replacement limitation applies. One advantage of Wiki.js's Git sync feature: after migration, you have a clean Git repository of all your documentation, which makes future migrations simpler. If you ever need to move from Wiki.js to another tool, you have a portable Markdown repository rather than a database dump. For teams evaluating the full range of Confluence alternatives, see Best Open Source Alternatives to Confluence 2026.

See open source alternatives to BookStack on OSSAlt.

BookStack vs Wiki.js 2026: Documentation Pick