Obsidian to Word: Export Notes & Documents to DOCX Format

Obsidian has rapidly become one of the most beloved note-taking applications among writers, researchers, students, and knowledge workers. Its local-first approach, powerful linking system, and extensible plugin ecosystem make it an exceptional tool for building a personal knowledge base and drafting long-form content. You can write entire manuscripts, research papers, and project documentation within Obsidian's comfortable Markdown editor, enjoying features like backlinks, graph view, and split panes that no traditional word processor can match.

However, the moment you need to share your work with someone outside the Obsidian ecosystem, you hit a wall. Professors expect .docx submissions. Clients want Word files they can mark up with Track Changes. Publishers require manuscripts in Word format. Your company's legal team will not review a .md file. The reality is that Microsoft Word remains the universal exchange format for professional documents, and converting your Obsidian notes to Word is a task you will face repeatedly.

This guide provides three complete methods for exporting Obsidian notes to Word, with special attention to handling Obsidian's unique syntax extensions that standard Markdown converters do not understand. Whether you prefer an in-app plugin, a browser-based tool, or a command-line approach, you will find a workflow that fits your needs.

The Challenge: Obsidian Syntax vs Standard Markdown

Obsidian uses a superset of standard Markdown that introduces several proprietary syntax elements. These extensions are what make Obsidian so powerful for knowledge management, but they create significant problems when you try to convert your notes to Word. A standard Markdown-to-Word converter will not know what to do with wiki links, callouts, or embedded notes, and the results can range from garbled formatting to completely missing content.

Understanding these syntax differences is the first step to achieving a clean conversion. Here are the key Obsidian-specific elements you need to be aware of:

Method 1 Pandoc Plugin (Recommended)

The Obsidian Pandoc Plugin is the most powerful and flexible method for exporting notes to Word. It leverages Pandoc, the universal document converter, to transform your Markdown into a properly formatted .docx file with native Word styles, table of contents support, and custom template integration. This method handles the widest range of Markdown features and produces the most professional output.

Prerequisites

• Pandoc installed on your system: Download from pandoc.org/installing.html. On macOS use brew install pandoc, on Windows use the MSI installer, on Linux use sudo apt install pandoc or your distribution's package manager.
• Obsidian 1.0 or later: The plugin requires a modern version of Obsidian with community plugin support.
• Community plugins enabled: In Obsidian Settings > Community Plugins, ensure Restricted Mode is turned off.

Step 1: Install the Pandoc Plugin

Step 2: Configure Export Settings

After installation, go to Settings > Pandoc Plugin to configure the export behavior. The most important settings are:

Step 3: Handle Obsidian-Specific Syntax

The Pandoc Plugin includes built-in handling for some Obsidian syntax, but you may need to manually adjust certain elements before exporting. The plugin automatically processes wiki links based on your "Internal link processing" setting. However, callouts, Dataview queries, and complex embeds may require pre-processing. Consider using the Obsidian Linter plugin alongside Pandoc to automatically clean up syntax before export, or manually review and edit problem areas in your note.

Step 4: Export Your Note to Word

Step 5: Review and Polish in Word

Open the exported document in Microsoft Word or a compatible application like LibreOffice Writer. Check the following areas that commonly need adjustment after conversion:

• Heading hierarchy: Verify that H1, H2, and H3 tags map correctly to Word's Heading 1, Heading 2, and Heading 3 styles.
• Table formatting: Wide tables may need column width adjustment. Merged cells from complex Markdown tables might not convert perfectly.
• Image sizing: Embedded images may appear at their full resolution. Resize as needed in Word.
• Callout blocks: If callouts were converted to blockquotes, you may want to apply custom Word styles (borders, background color) to make them visually distinct.
• Page breaks: Add manual page breaks before major sections if the document is intended for print.

Method 2 Copy-Paste to Online Converter

If you do not want to install Pandoc or configure plugins, the simplest approach is to copy your note's Markdown content and paste it into a browser-based converter. This method requires no setup and works on any operating system, including Chromebooks and tablets where installing desktop software is not possible.

How It Works

Method 3 Enhancing Markdown Export Plugin

The Enhancing Markdown Export community plugin (also known as "Markdown Export" or "Better Export PDF") takes a different approach to document conversion. Instead of piping through Pandoc, this plugin renders your note through Obsidian's own rendering engine and then converts the rendered output. This means it can handle Obsidian-specific features like callouts, Mermaid diagrams, and even some Dataview results because it captures what Obsidian actually displays.

Installation and Setup

Install the plugin from Settings > Community Plugins > Browse by searching for "Enhancing Export." Enable it and configure the output format. While this plugin is primarily designed for PDF export, it can also produce HTML output that you can then convert to Word using Pandoc or an online tool. The advantage is that the HTML intermediate faithfully represents what you see in Obsidian's reading view, including rendered callouts and diagrams.

Two-Step Workflow: Obsidian to HTML to Word

# Export from Obsidian as HTML, then convert to Word with Pandoc
pandoc exported-note.html -o final-document.docx -f html -t docx --reference-doc=template.docx

This two-step approach preserves more Obsidian-specific formatting than direct Markdown-to-Word conversion because the HTML intermediate captures Obsidian's rendered callout styles, syntax-highlighted code blocks, and custom CSS classes. The trade-off is an extra step in your workflow and the need for Pandoc to handle the HTML-to-DOCX conversion.

Handling Obsidian-Specific Elements

The following reference table shows each Obsidian syntax element, how it appears in raw Markdown, and the recommended approach for converting it to Word. Use this as a checklist when preparing your notes for export.

Working with Obsidian Attachments

Obsidian stores attachments (images, PDFs, audio files, and other media) within your vault's file system, typically in a dedicated attachments folder. When converting to Word, handling these attachments correctly is crucial for a complete document. Here is how to approach each type of attachment.

Images

Obsidian references images using either wiki link syntax (![[image.png]]) or standard Markdown syntax (![alt](path/image.png)). For Word export with the Pandoc Plugin, images referenced with standard Markdown syntax are automatically embedded in the DOCX file, provided the path is correct relative to the note's location. Wiki link image embeds need to be converted to standard syntax first.

If your vault uses a centralized attachments folder (e.g., vault/attachments/), you may need to adjust image paths to be relative to the note being exported. For example, if your note is at vault/notes/my-note.md and images are in vault/attachments/, the image path should be ../attachments/image.png. Alternatively, specify the resource path in your Pandoc arguments:

# In Pandoc Plugin settings, add to "Extra Pandoc arguments":
--resource-path=/path/to/your/vault/attachments

Embedded PDFs

Obsidian can embed PDFs inline using ![[document.pdf]] syntax, displaying them as scrollable viewers within the note. Word does not support embedded PDF viewing. The best approach is to replace PDF embeds with a descriptive link or reference: See attached: [document.pdf](./attachments/document.pdf). If you need the PDF content in the Word document, consider extracting the relevant pages as images and inserting them.

Audio and Video Files

Audio (![[recording.mp3]]) and video (![[video.mp4]]) embeds have no Word equivalent. Replace these with descriptive text indicating the media file, such as "[Audio recording: interview-2026-03-19.mp3]". If transcripts are available, consider including the transcript text in the Word document instead.

Batch Export from Obsidian Vault

When you need to convert multiple notes from your Obsidian vault to Word documents at once -- for archival, migration, or bulk delivery -- manual one-by-one export is not practical. Here are two approaches for batch conversion that scale from a handful of notes to an entire vault.

Approach 1: Shell Script with Pandoc

Since Obsidian stores notes as plain .md files on your file system, you can use a simple shell script to batch-convert them with Pandoc. This approach works on macOS, Linux, and Windows (via Git Bash or WSL).

#!/bin/bash
# Batch convert all Markdown files in an Obsidian vault to Word
# Usage: ./batch-convert.sh /path/to/vault /path/to/output

VAULT_DIR="$1"
OUTPUT_DIR="$2"
TEMPLATE="$VAULT_DIR/templates/reference.docx"  # Optional Word template

mkdir -p "$OUTPUT_DIR"

find "$VAULT_DIR" -name "*.md" -not -path "*/\.*" | while read -r mdfile; do
    # Get relative path and create output filename
    relative="${mdfile#$VAULT_DIR/}"
    outfile="$OUTPUT_DIR/${relative%.md}.docx"
    outdir=$(dirname "$outfile")
    mkdir -p "$outdir"

    echo "Converting: $relative"

    # Pre-process: strip wiki links [[text]] to just text
    sed -E 's/\[\[([^]|]+)\|([^]]+)\]\]/\2/g; s/\[\[([^]]+)\]\]/\1/g' "$mdfile" | \
    pandoc -f markdown -t docx -o "$outfile" \
        --resource-path="$VAULT_DIR" \
        ${TEMPLATE:+--reference-doc="$TEMPLATE"}
done

echo "Batch conversion complete. Output: $OUTPUT_DIR"

Approach 2: Python Script with Advanced Processing

For more control over the conversion process -- including callout transformation, tag removal, and Dataview query stripping -- a Python script provides the flexibility you need. This script pre-processes each Markdown file to handle Obsidian-specific syntax before passing it to Pandoc.

import os
import re
import subprocess
import sys

def preprocess_obsidian_md(content):
    """Clean Obsidian-specific syntax for standard Markdown conversion."""
    # Convert aliased wiki links: [[target|display]] -> display
    content = re.sub(r'\[\[([^\]|]+)\|([^\]]+)\]\]', r'\2', content)
    # Convert plain wiki links: [[target]] -> target
    content = re.sub(r'\[\[([^\]]+)\]\]', r'\1', content)
    # Convert image embeds: ![[image.png]] -> ![](image.png)
    content = re.sub(r'!\[\[([^\]]+\.(png|jpg|jpeg|gif|svg|webp))\]\]',
                     r'![](\1)', content, flags=re.IGNORECASE)
    # Clean callout syntax: > [!note] Title -> > **Note:** Title
    content = re.sub(r'^(>\s*)\[!(\w+)\]\s*(.*)$',
                     lambda m: f'{m.group(1)}**{m.group(2).title()}:** {m.group(3)}',
                     content, flags=re.MULTILINE)
    # Remove Dataview code blocks
    content = re.sub(r'```dataview\n.*?```', '', content, flags=re.DOTALL)
    # Remove inline tags (but not headings)
    content = re.sub(r'(?<!\n)#[\w/]+', '', content)
    return content

def batch_convert(vault_path, output_path):
    os.makedirs(output_path, exist_ok=True)
    for root, dirs, files in os.walk(vault_path):
        # Skip hidden directories
        dirs[:] = [d for d in dirs if not d.startswith('.')]
        for filename in files:
            if not filename.endswith('.md'):
                continue
            md_path = os.path.join(root, filename)
            rel_path = os.path.relpath(md_path, vault_path)
            docx_path = os.path.join(output_path,
                                     os.path.splitext(rel_path)[0] + '.docx')
            os.makedirs(os.path.dirname(docx_path), exist_ok=True)

            with open(md_path, 'r', encoding='utf-8') as f:
                content = preprocess_obsidian_md(f.read())

            # Pipe processed content to Pandoc
            result = subprocess.run(
                ['pandoc', '-f', 'markdown', '-t', 'docx', '-o', docx_path,
                 f'--resource-path={vault_path}'],
                input=content, text=True, capture_output=True
            )
            status = "OK" if result.returncode == 0 else f"ERROR: {result.stderr}"
            print(f"  {rel_path} -> {status}")

if __name__ == '__main__':
    batch_convert(sys.argv[1], sys.argv[2])

Frequently Asked Questions