Batch Export Your Obsidian Vault to Google Docs and Word

You have a vault full of notes. Maybe you are migrating away from Obsidian. Maybe your company needs everything in Google Docs. Maybe you are archiving a project and the stakeholders want Word files. Whatever the reason, you need to get many notes out of Obsidian and into a different format, not just one note at a time.

This is surprisingly hard. Obsidian has no native batch export to formatted documents. The tools that exist require either technical skills or a lot of manual repetition. This guide covers every realistic option, from the manual approach to scripted automation, with an honest assessment of what each one involves.

Why batch export from Obsidian is difficult

Obsidian stores your notes as plain .md files in a folder on your computer. In theory, this makes export trivial: the files are already accessible. In practice, the challenge is not accessing the files but converting them into properly formatted documents that look professional in Google Docs or Word.

The raw markdown files contain syntax that neither Google Docs nor Word understands natively. Headings are lines starting with #. Tables are pipe characters and dashes. Bold text is wrapped in **asterisks**. Code blocks are fenced with triple backticks. If you upload a .md file to Google Docs, you get a plain text document with all the markdown syntax visible.

Obsidian also supports extended syntax that is not part of standard markdown: wikilinks ([[page name]]), callouts (> [!note]), dataview queries, tags, block references, and embedded files. None of these have equivalents in Google Docs or Word, so any conversion process needs to handle them gracefully (usually by stripping or converting them to plain text).

The combination of standard markdown conversion and Obsidian-specific syntax handling makes this a harder problem than it looks.

Option 1: Obsidian's built-in PDF export

Obsidian can export individual notes to PDF. You can also select multiple notes in the file explorer, right-click, and export them as PDFs. This is the closest thing to a native batch export.

What works: You get a PDF for each note (or a combined PDF, depending on your approach). The formatting is based on Obsidian's rendering, so headings, lists, and basic formatting transfer.

What does not work: The quality varies. Tables can overflow the page. Code blocks may not wrap properly. And you end up with PDFs, not editable Google Docs or Word files. Google Docs can import PDFs, but the conversion to an editable document produces approximate formatting. Tables become images or lose their structure. Headings lose their semantic levels. The result often needs as much manual cleanup as if you had started from scratch.

Verdict: Acceptable for archival purposes where you just need a readable copy. Not viable if you need editable, properly formatted documents.

Option 2: Pandoc (command line)

Pandoc is a free, open-source document converter. It handles markdown to DOCX conversion well for standard markdown. With a shell script, you can automate it across your entire vault.

Here is what a basic batch conversion script looks like:

#!/bin/bash
# Convert all .md files in an Obsidian vault to .docx
VAULT_DIR="$HOME/Documents/MyVault"
OUTPUT_DIR="$HOME/Documents/VaultExport"

mkdir -p "$OUTPUT_DIR"

find "$VAULT_DIR" -name "*.md" | while read -r file; do
  # Preserve directory structure
  relative_path="${file#$VAULT_DIR/}"
  output_path="$OUTPUT_DIR/${relative_path%.md}.docx"
  output_dir=$(dirname "$output_path")
  mkdir -p "$output_dir"

  pandoc "$file" -o "$output_path" --from=markdown --to=docx
done

echo "Exported $(find "$OUTPUT_DIR" -name "*.docx" | wc -l) files"

What works: Standard markdown converts cleanly. Headings, lists, bold, italic, links, and code blocks all produce proper Word formatting. You can process hundreds of files in seconds. And the output is .docx, which both Word and Google Docs handle natively.

What does not work: Obsidian-specific syntax is not handled. Wikilinks appear as literal [[text]]. Callouts show up as raw blockquote syntax. Dataview queries render as code blocks. Tags appear as plain text with # prefixes. You would need additional preprocessing to strip or convert these elements.

Pandoc also requires installation and command-line familiarity. On macOS, you install it via Homebrew (brew install pandoc). On Windows, you download an installer. If you have never used a terminal, the setup is a real barrier.

Verdict: The best option for technically comfortable users who need to convert many standard-markdown files at once. Requires command-line skills and does not handle Obsidian-specific extensions.

Option 3: Community plugins (one at a time)

Several Obsidian plugins improve single-note export quality. Enhancing Export, for example, offers better PDF and Word output than the built-in export. But these plugins operate on individual notes. There is no "export all" button.

For a vault with dozens of notes, this means opening each note, running the export command, and saving the output file. For a vault with hundreds of notes, this is not realistic.

Verdict: Fine for exporting a handful of important notes. Not a batch solution.

Option 4: Manual copy-paste through Unmarkdown

For individual notes, the Unmarkdown™ workflow is straightforward: open a note in Obsidian, copy the markdown, paste it into Unmarkdown™, choose a template, and copy for your destination (Google Docs or Word). The formatting transfers correctly, including headings, tables, code blocks, and lists.

This is still a one-at-a-time process. But it is significantly faster than the alternatives for individual notes because there is no setup. No installation, no command-line tools, no plugins. Open the browser, paste, copy, paste into the destination. The entire cycle takes about 30 seconds per note.

What works: Clean formatting for every destination. 62 templates for styling. AI editing can polish content during the conversion. No tools to install or configure.

What does not work: It is manual. For a handful of priority notes, this is fine. For a full vault migration, it is tedious.

Verdict: Best for selectively exporting important notes with high-quality formatting. Not suitable for exporting an entire vault.

Option 5: Unmarkdown API (scripted batch export)

For developers who need true batch export with professional formatting, the Unmarkdown™ API offers a programmatic approach. You can write a script that reads .md files from your vault and converts each one through the API.

Here is a conceptual example:

const fs = require("fs");
const path = require("path");

const VAULT_DIR = "/Users/you/Documents/MyVault";
const API_KEY = "um_your_api_key_here";

async function convertFile(filePath) {
  const markdown = fs.readFileSync(filePath, "utf-8");

  const response = await fetch("https://unmarkdown.com/api/convert", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      markdown,
      destination: "google-docs",
      template_id: "executive",
    }),
  });

  const data = await response.json();
  return data.html;
}

// Process all .md files
async function batchExport() {
  const files = fs
    .readdirSync(VAULT_DIR, { recursive: true })
    .filter((f) => f.endsWith(".md"));

  for (const file of files) {
    const html = await convertFile(path.join(VAULT_DIR, file));
    console.log(`Converted: ${file}`);
    // Save HTML or use Google Docs API to create documents
  }
}

batchExport();

This approach gives you Unmarkdown™'s full formatting pipeline (templates, proper heading styles, destination-specific output) applied to every file in your vault. You can choose any of the 62 templates, target any destination format, and process hundreds of files automatically.

What works: Full batch automation with professional formatting. Template consistency across all documents. Destination-specific output.

What does not work: This requires writing code. You need to be comfortable with JavaScript (or any language that can make HTTP requests), and you need an Unmarkdown™ API key. The free tier includes 1,000 API calls per month, which covers small to medium vaults. Larger vaults may require a Pro subscription (10,000 calls/month included).

Verdict: The best option for developers who want both batch automation and high-quality formatting. Requires programming skills and an API key.

A practical strategy

Most people do not need to export their entire vault. The reality is that a typical Obsidian vault contains a mix of permanent reference notes, temporary scratch notes, daily journals, and everything in between. Exporting all of it is usually not the goal.

A more practical approach is to prioritize.

Identify the notes that actually need to leave Obsidian. Which notes need to be shared with colleagues? Which ones need to be in Google Docs for collaboration? Which ones are being archived for a specific project?

Use the right tool for the volume. For 5 to 10 priority notes, the manual Unmarkdown™ workflow is fast and produces the best formatting. For 50 or more standard-markdown files, a Pandoc script is efficient if you are comfortable with the command line. For batch export with professional formatting, the API is the way to go.

Accept that some content is vault-specific. Notes built around Obsidian features like dataview queries, canvas boards, and extensive wikilinks are designed for Obsidian. They do not translate well to any external format. These are better left in Obsidian or recreated in the destination tool rather than converted.

The honest summary

Batch exporting an Obsidian vault to Google Docs or Word is a gap in the current tool ecosystem. There is no single-click solution that handles it all. The best approach depends on your technical skills, the number of notes you need to export, and how important formatting quality is for your use case.

No approach is perfect. But knowing the tradeoffs for each option lets you pick the one that fits your situation instead of discovering the limitations halfway through.

Try the Unmarkdown plugin for Obsidian

Unmarkdown is now available as an Obsidian community plugin. Right-click any note and copy it formatted for Google Docs, Word, Slack, OneNote, Email, or Plain Text, directly from your vault. You can also publish notes to the web with 62 templates.

How to install (Community Plugins directory approval pending):

1. Download main.js, manifest.json, and styles.css from the latest release
2. In your vault, create the folder .obsidian/plugins/unmarkdown/
3. Move the three downloaded files into that folder
4. Open Obsidian Settings > Community Plugins > Enable "Unmarkdown"
5. Go to Settings > Unmarkdown > Click "Connect account" to link your free Unmarkdown account

Once approved for the Community Plugins directory, you can install by searching "Unmarkdown" in Obsidian's plugin browser.

Related reading

• How to Export Obsidian Notes to Google Docs Without Losing Formatting
• Why Obsidian Loses Formatting When You Copy-Paste (and How to Fix It)
• Obsidian vs Unmarkdown: When You Need Documents, Not Digital Gardens
• The AI Formatting Problem Nobody Talks About (And How to Fix It)