DEV Community: Yamuno

Export Confluence Pages to Polished PDFs — Introducing PDF Exporter for Confluence

Yamuno — Thu, 23 Apr 2026 14:04:25 +0000

Introducing PDF Exporter for Confluence

We're excited to announce that PDF Exporter for Confluence is now live on the Atlassian Marketplace.

Confluence's built-in PDF export is minimal — no cover page, no custom headers, no watermarks, and certainly no reusable templates. For teams sharing documentation with clients, stakeholders, or regulators, "minimal" doesn't cut it.

PDF Exporter fills that gap.

What Is PDF Exporter for Confluence?

PDF Exporter is a Forge-native Confluence Cloud app that lets you export any page, page hierarchy, or entire space to a professionally formatted PDF — without leaving Confluence and without sending your data anywhere outside Atlassian's infrastructure.

Key Features

Single Page, Hierarchy, or Full Space

Export exactly what you need:

Single page — export any Confluence page to PDF in one click
Page tree — select a parent page and include all child pages in one export
Full space — export an entire Confluence space as a packaged ZIP of PDFs

Multi-page exports are automatically bundled into a ZIP download.

Reusable Templates

Admins can define export templates from Confluence Settings → PDF Exporter. Each template controls fonts, layout, cover page style, header and footer content, watermarks, and page numbering.

Once a template is saved, every user on the instance can apply it — no more inconsistent formatting across teams.

Six Cover Page Styles

Choose from six built-in cover page layouts and customise them with your accent color, company logo, author name, and subtitle. Every exported PDF looks like it came from your design team.

Automatic Table of Contents

Enable the TOC option and the exporter automatically generates a clickable table of contents from your page headings — with configurable depth so you control how detailed it gets.

Headers, Footers & Watermarks

Add custom text, page numbers, or a watermark to every page of the exported PDF. Useful for draft reviews, confidential documents, or any output where you need persistent labelling.

Runs Entirely on Atlassian Forge

PDF Exporter is 100% Forge-native. All processing happens inside Atlassian's infrastructure — exported PDFs are delivered directly to your browser and never stored on external servers.

Who Is It For?

PDF Exporter is built for teams that share documentation beyond Confluence:

Technical writers producing release notes, product specs, or user guides for external distribution
Solutions engineers creating polished client-facing proposals or handover documents
Compliance and legal teams archiving Confluence content with consistent formatting and watermarks
Project managers sharing status reports and project documentation with stakeholders who don't have Confluence access

Getting Started

Install the app from the Atlassian Marketplace
Open any Confluence page and click ••• (More actions) → Export to PDF
Choose a template (or use the default)
Select the scope — single page, page tree, or space
Click Export and download your PDF

Admins can create and manage templates from Confluence Settings → PDF Exporter.

👉 Install PDF Exporter for Confluence

👉 Read the Documentation

Questions or feedback? Reach out via our support portal — we'd love to hear how your team is using it.

How to Migrate Your GitHub or GitLab Docs to Confluence (Step-by-Step)

Yamuno — Thu, 23 Apr 2026 13:59:26 +0000

How to Migrate Your GitHub or GitLab Docs to Confluence

Engineering teams often end up with documentation scattered across two places: a docs/ folder in the repo, and a Confluence space that slowly falls behind. This guide shows you how to close that gap — whether you want a one-time migration, a bulk import, or a fully automated sync that keeps Confluence updated on every push.

Why Teams Move Docs to Confluence

Keeping docs in Git is great for developers, but it creates friction for everyone else. Product managers, support teams, and stakeholders usually live in Confluence — not in GitHub. When your README and architecture docs live in a repo, they become invisible to half the company.

At the same time, manually copy-pasting markdown into Confluence is tedious and breaks formatting. The goal is to do this once, correctly, and then keep it in sync automatically.

What You Need

Confluence Cloud (any plan)
Markdown Exporter & Importer for Confluence installed
Your markdown files from GitHub or GitLab (as a ZIP or local clone)

Option 1 — Import a Single File

Best for: migrating a single README, architecture doc, or changelog.

Open the target Confluence page where you want the content to live
Click the ••• (More actions) menu → Markdown Importer & Exporter
Select Import and choose your .md or .mdx file
Preview the output, then click Import

Your markdown — including headers, tables, code blocks, and images — is converted to native Confluence content.

Option 2 — Bulk Import from a ZIP Archive

Best for: migrating an entire docs/ folder from a repo in one shot.

Step 1 — Clone and zip your docs folder

git clone https://github.com/your-org/your-repo.git
cd your-repo
zip -r docs-export.zip docs/

For GitLab, it's the same process — or use the GitLab UI: Repository → Files → docs/ → Download this directory.

Step 2 — Import the ZIP into Confluence

In Confluence, navigate to the space or page where you want the docs imported
Open the ••• menu → Markdown Importer & Exporter
Select Import and upload your docs-export.zip
Review the file tree — the importer shows all files and their resolved hierarchy before importing

Step 3 — Confirm hierarchy

The importer converts your folder structure into a Confluence page tree. A structure like:

docs/
  getting-started/
    installation.md
    quick-start.md
  api/
    overview.md
    authentication.md

…becomes parent/child pages in Confluence exactly as you'd expect — no manual reorganisation needed.

Step 4 — Handle images and attachments

If your markdown references local images (e.g. ![diagram](./assets/arch.png)), include the assets folder in the ZIP. The importer uploads them as Confluence attachments and rewires the image references automatically.

Option 3 — Automate with CI/CD (GitHub Actions / GitLab CI)

Best for: keeping Confluence permanently in sync with your repo. Every push updates the docs without anyone touching Confluence manually.

Prerequisites

You'll need two things from the Markdown Importer app:

In Confluence, go to Settings → Apps → Markdown Importer for Confluence → API tab
Click Create New Token, give it a label (e.g. ci-cd-pipeline), set an expiration, and copy it immediately
On the same page, copy your unique API endpoint URL — it looks like:

   https://your-site.atlassian.net/wiki/apps/<app-id>/<env-id>/webtrigger

Store both as secrets in your repo:
- GitHub: Settings → Secrets → CONFLUENCE_API_ENDPOINT + CONFLUENCE_API_TOKEN
- GitLab: Settings → CI/CD → Variables → same two variables

You'll also need your Confluence space ID and parent page ID — both are visible in the app's space and page selectors.

GitHub Actions Workflow

Create .github/workflows/sync-docs.yml:

name: Sync docs to Confluence

on:
  push:
    branches: [main]
    paths:
      - "docs/**"

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Import README to Confluence
        run: |
          CONTENT=$(cat docs/README.md | jq -Rs .)
          curl -X POST "${{ secrets.CONFLUENCE_API_ENDPOINT }}" \
            -H "Authorization: Bearer ${{ secrets.CONFLUENCE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{\"spaceId\":\"DOCS\",\"parentId\":\"123456789\",\"pageTitle\":\"README\",\"content\":$CONTENT,\"overwrite\":true}"

      - name: Import API docs
        run: |
          CONTENT=$(cat docs/api.md | jq -Rs .)
          curl -X POST "${{ secrets.CONFLUENCE_API_ENDPOINT }}" \
            -H "Authorization: Bearer ${{ secrets.CONFLUENCE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{\"spaceId\":\"DOCS\",\"parentId\":\"123456789\",\"pageTitle\":\"API Reference\",\"content\":$CONTENT,\"overwrite\":true}"

The API sends one page per request as JSON — add a step per file you want to keep in sync. The workflow only triggers when files under docs/ change.

GitLab CI Pipeline

Add to .gitlab-ci.yml:

stages:
  - deploy-docs

deploy-confluence:
  stage: deploy-docs
  only:
    - main
  script:
    - |
      curl -X POST "$CONFLUENCE_API_ENDPOINT" \
        -H "Authorization: Bearer $CONFLUENCE_API_TOKEN" \
        -H "Content-Type: application/json" \
        -d "{
          \"spaceId\": \"DOCS\",
          \"parentId\": \"123456789\",
          \"pageTitle\": \"API Documentation\",
          \"content\": $(cat docs/api.md | jq -Rs .),
          \"overwrite\": true
        }"

Store CONFLUENCE_API_ENDPOINT, CONFLUENCE_API_TOKEN as masked CI/CD variables in GitLab.

Tips for a Clean Migration

Organise before you import. Rename files with a numeric prefix if you care about order (01-overview.md, 02-installation.md). The importer preserves file order when importing via the UI.

Handle frontmatter. If your docs use YAML frontmatter (like many Docusaurus or MkDocs setups), the importer reads title from frontmatter and uses it as the Confluence page title. No need to strip it out.

Check internal links. Links between pages (e.g. [see here](../api/overview.md)) are resolved relative to the page hierarchy during import. Cross-check a few after importing to confirm they resolve correctly.

Run a test import first. Pick a small subfolder, import it into a sandbox space, and confirm the output looks right before running the full migration.

Getting Started

Install Markdown Exporter & Importer for Confluence from the Atlassian Marketplace — it's free to try.

For the CI/CD approach, check out the REST API documentation for the full list of parameters, authentication details, and code examples in Node.js, Python, and Go.

Questions or edge cases? Reach out via our support portal — we're happy to help with migration planning.

Markdown Importer v6.0.0 is Here – Early Conflict Detection, Performance Updates & UI Enhancements!

Yamuno — Thu, 23 Apr 2026 13:59:12 +0000

Markdown Importer v6.0.0 is Here 🚀

We're excited to announce the release of Markdown Importer for Confluence v6.0.0! This update brings powerful new features, performance improvements, and a refreshed interface to make importing Markdown files into Confluence easier and more reliable than ever.

🌟 What's New in v6.0.0

🔍 Early Conflict Detection

One of the biggest challenges when importing files into Confluence is dealing with duplicate names for pages and folders. With v6.0.0, we've introduced early conflict detection to identify these issues before they cause problems. You'll now be able to:

Detect conflicting files and folders before importing
Choose whether to skip, or resolve conflicts directly
Save time and avoid messy post-import cleanups

⚡ Performance Updates

Large imports can now be processed faster and more efficiently. We've optimized our backend logic to handle heavy workloads, so whether you're importing a small set of documents or an entire knowledge base, you'll experience smoother and quicker performance.

🎨 UI Enhancements

We've refreshed the user interface to make the importing process more intuitive. Cleaner layouts, improved navigation, and a more modern look ensure that you can focus on your content without friction.

💡 Why This Matters

Markdown Importer is designed to help teams seamlessly bring their existing documentation into Confluence. With these improvements, you'll spend less time fixing issues and more time collaborating on what matters most. Check out our documentation to learn more about all the features.

🔗 Try It Now

Upgrade to the latest version and experience the improvements yourself:

👉 Markdown Importer for Confluence on Atlassian Marketplace

We'd love to hear your feedback! Reach out via our support channel. Your input helps us continue improving the app to better fit your workflows.

Want to see the full changelog? Visit our release notes page.

✅ Ready to import smarter, faster, and more reliably?

Update to Markdown Importer v6.0.0 today!

New Features in Markdown Importer for Confluence – Unlimited Bulk Import, Hierarchy Support, and More!

Yamuno — Thu, 23 Apr 2026 13:53:46 +0000

🚀 Big Update for Markdown Importer for Confluence!

We’ve just rolled out a major upgrade to make importing your Markdown content into Confluence faster, smarter, and more powerful than ever.

✨ What’s New

✅ Unlimited Bulk Import

Bring in as many files as you need — all at once.

✅ Folder & File Hierarchy Support

Upload ZIP files while preserving your original folder and file structure.

✅ Attachment Upload Support

Automatically include all attachments referenced in your files.

✅ Multiple Access Modes

Choose between global or per-page access controls for better security and collaboration.

Whether you’re migrating projects, organizing documentation, or collaborating at scale, this update makes it seamless.

🔗 Check it out here:
Markdown Importer for Confluence – Atlassian Marketplace

📚 Read the docs: Markdown Importer for Confluence Documentation

Introducing REST API for Markdown Importer – Automate Your Documentation Workflow!

Yamuno — Thu, 23 Apr 2026 13:53:32 +0000

Introducing REST API for Markdown Importer 🚀

We're thrilled to announce a game-changing addition to Markdown Importer for Confluence – a powerful REST API that unlocks automation and integration possibilities for your documentation workflow!

Say goodbye to manual imports and hello to seamless, programmatic documentation updates directly from your CI/CD pipeline, external applications, or custom automation scripts.

🌟 What's New in v6.4.0

The new REST API transforms how you manage Confluence documentation by enabling programmatic markdown imports from anywhere. Whether you're syncing docs from GitHub, deploying from GitLab CI/CD, or building custom integrations, the API makes it effortless.

Key Features

🔐 Secure Token Management
Generate and manage API tokens with JWT-based authentication, fine-grained expiration control (1-30 days), and the ability to create up to 50 tokens for different environments.

🚀 Simple HTTP Requests
Import markdown content with a straightforward POST request – no complex setup required.

🔄 Smart Conflict Handling
Choose to create new pages or update existing ones with built-in overwrite support and clear error handling.

📚 Comprehensive Documentation
From getting started guides to production best practices, we've got you covered with complete API documentation, code examples in multiple languages, and CI/CD workflow templates.

💡 Perfect For

CI/CD Pipelines
Automatically sync documentation with every code push. Keep your Confluence pages updated alongside your codebase without manual intervention.

Documentation Migration
Moving from another platform? Script your migration and import hundreds of markdown files programmatically with consistent formatting.

Automated Updates
Trigger documentation updates from external systems, webhooks, or scheduled jobs. Perfect for keeping release notes, changelogs, and API docs fresh.

Custom Workflows
Build exactly the integration you need – whether it's generating docs from code comments, syncing from multiple sources, or creating dynamic content.

🎯 Why It Matters

Documentation should evolve with your product, not lag behind it. The REST API eliminates the manual bottleneck, letting you:

✅ Automate repetitive import tasks
✅ Synchronize docs with code changes automatically
✅ Scale from single files to enterprise-wide migrations
✅ Integrate with your existing tools and workflows

📖 Ready to Get Started?

We've prepared comprehensive documentation to help you integrate the API into your workflow:

👉 View Complete API Documentation

Our documentation includes:

Quick start guide with step-by-step token setup
Complete API reference with all endpoints and parameters
Ready-to-use code examples in cURL, Node.js, Python, Go, and more
CI/CD workflow templates for GitHub Actions and GitLab
Production-ready best practices and troubleshooting tips

🎉 Try It Now

The REST API is available now for all Markdown Importer for Confluence users!

✅ Included with your license – No additional cost
✅ Available during trial – Test it before you buy
✅ Production-ready – Built for scale and reliability

💬 We Want Your Feedback

We'd love to hear how you're using the REST API! Share your use cases, integrations, or feedback:

📧 Contact Support
📝 View Full Changelog

Get Markdown Importer for Confluence and start automating your documentation workflow today!

Ready to automate your documentation? The REST API is waiting for you! 🚀

Introducing Markdown Exporter – Now Part of Markdown Importer for Confluence (v7.0.0)

Yamuno — Thu, 23 Apr 2026 13:48:06 +0000

🚀 Introducing Markdown Exporter – Now Part of Markdown Importer for Confluence (v7.0.0)

We’re excited to announce v7.0.0 of Markdown Importer for Confluence, now featuring the all-new Markdown Exporter! 🎉

With this update, the app transitions from being Markdown Import-only to a full two-way Markdown solution — enabling teams to import Markdown files into Confluence and export Confluence pages back to clean Markdown. 💪

This addition makes documentation workflows more flexible, efficient, and automation-friendly, whether you’re syncing content with external tools, managing backups, or integrating with CI/CD pipelines.

✨ Key Features of the Exporter

📤 Export Confluence Pages to Markdown

Easily export Confluence pages to structured Markdown files, preserving page hierarchy, attachments, and formatting for smooth version control and external documentation workflows. 🗂️

📥 Import Markdown Files (Existing Feature)

Continue to import Markdown files with seamless bulk support, preserved folder structures, and accurate formatting. ⚡

🔗 Automation & REST API Support

Use REST API with JWT authentication and expiring API tokens to automate imports and exports. Built-in conflict detection ensures your workflows remain smooth. 🤖

🌙 User-Friendly Interface

Bulk operations are simple with dark mode and an intuitive UI, ideal for large-scale documentation projects. 🖥️

💡 Why Teams Love It

⏱ Save Time: No manual copy-paste between Markdown and Confluence
✅ Maintain Accuracy: Formatting, attachments, and hierarchy remain intact
🚀 Boost Productivity: Integrate with automated workflows, CI/CD, and external tools
⚡ Designed for Fast-Moving Teams: Lightweight, efficient, and reliable

🎯 Get Started Today

Experience the power of Markdown Exporter & Importer for Confluence (v7.0.0). Import Markdown, export Confluence pages, and automate your documentation workflows with ease.

👉 Get it on the Atlassian Marketplace

Switching LaTeX Math Apps in Confluence? We Made It Painless.

Yamuno — Thu, 23 Apr 2026 13:47:53 +0000

Switching LaTeX Math Apps in Confluence? We Made It Painless.

If you've ever tried to switch from one LaTeX math app to another in Confluence, you know the pain. Hundreds of pages, thousands of equations, all locked into a vendor-specific format. Manually re-entering every formula is not an option.

That's why we built Migration Support directly into LaTeX Math for Confluence.

The Problem

Teams across engineering, academia, and finance rely on LaTeX equations in their Confluence documentation. But what happens when your current math app doesn't cut it anymore? Maybe the rendering is slow. Maybe it lacks features you need. Maybe the pricing changed.

Whatever the reason, you're stuck. Your formulas are embedded in a proprietary macro format, scattered across dozens of spaces and hundreds of pages. Moving to a new app means either:

Manually finding and re-entering every single equation, or
Living with an app that no longer meets your needs.

Neither is acceptable.

The Solution: One-Click Migration

LaTeX Math for Confluence now includes a built-in migration tool that automatically finds, converts, and replaces equations from other LaTeX math apps across your entire Confluence instance.

Here's how it works:

Step 1: Choose Your Source App

Open the migration tab in the app's configuration settings. Select the app you're migrating from. We currently support:

LaTeX and MathJax by The Plugin People
LaTeX Math by Appfire
LaTeX Math Lite by Appfire
LaTeX Math (Easy Math) by Narva Software

Need to migrate from an app not on the list? The Advanced tab lets you enter any macro name manually.

Step 2: Search Your Spaces

Select a Confluence space to scan, or search across your entire instance. The tool uses Confluence's query language under the hood to find every page that contains equations from your source app.

Results are displayed in a clear table showing the page title, space, and last modified date so you know exactly what you're working with.

Step 3: Migrate

Select the pages you want to migrate and hit the button. The tool handles the rest:

Extracts the LaTeX formula from the old macro format
Converts it to the LaTeX Math for Confluence format
Preserves alignment settings (left, center, right)
Maps inline equations to inline macros and block equations to block macros
Updates the page with proper version tracking

Every migration is recorded in the page's version history, so you always have a clear audit trail.

What Makes This Different

It Handles the Format Chaos

Different apps store LaTeX in wildly different ways. Some use XML parameters, others use rich text bodies, others use ADF extensions. Some wrap formulas in CDATA sections, others encode them as plain parameters.

Our migration engine understands all of these formats. It extracts your LaTeX from whatever structure the source app used and converts it cleanly.

It's Safe

Migration doesn't delete your original content. Confluence's version history means you can always roll back any page to its pre-migration state. The tool also reports success and failure counts for every batch, so you know immediately if something needs attention.

It Scales

Whether you have 10 pages or 10,000, the migration tool handles pagination and batch processing. It works through your pages methodically, updating each one and moving on, without overwhelming the Confluence API.

It's Built for Real Teams

We didn't build this for a demo. We built it because real users asked for it. Teams running thousands of equations across enterprise Confluence instances need a way to switch apps without losing a week of productivity.

Advanced Mode

For power users and admins dealing with custom or less common apps, the Advanced tab offers full control:

Enter any macro name to search for
Filter by body content
Target specific spaces
Handle edge cases that the standard wizard might not cover

Get Started

Migration support is available now in LaTeX Math for Confluence. Open your app configuration, navigate to the "Migrate from other apps" tab, and run your first search. You'll see exactly how many equations you can migrate before committing to anything.

No manual work. No lost formulas. No downtime.

Your equations deserve better. Move them in minutes, not months.

LaTeX Math for Confluence supports both KaTeX and MathJax rendering, inline and block equations, chemical formulas, physics notation, and more. Available on the Atlassian Marketplace.

Beautiful Mathematical Equations in Confluence – Introducing LaTeX Math for Confluence!

Yamuno — Thu, 23 Apr 2026 13:42:29 +0000

Introducing LaTeX Math for Confluence

We're excited to announce the launch of LaTeX Math for Confluence! Finally, you can create professional, publication-quality mathematical equations directly in your Confluence documentation with the power and precision of LaTeX.

🌟 What Makes LaTeX Math for Confluence Special

🧮 Professional Math Rendering

Create beautiful mathematical equations using the industry-standard LaTeX syntax, powered by KaTeX for fast, crisp rendering:

Comprehensive LaTeX Support: Fractions, matrices, integrals, summations, Greek symbols, and more
Crystal-Clear Output: High-quality rendering that looks perfect at any size
Publication-Ready: Professional typesetting suitable for technical documentation, research papers, and educational materials

⚡ Live Preview Editor

See your equations come to life as you type:

Real-Time Rendering: Watch your LaTeX code transform into beautiful equations instantly
Error Detection: Catch syntax errors before saving
Instant Feedback: No more guessing how your equation will look

📝 Flexible Macro Options

Choose the perfect format for your equations:

Inline Macros: Embed equations within text paragraphs (like (x^2 + y^2 = r^2))
Block Macros: Display equations prominently on their own line with proper spacing
Easy Insertion: Type /latex or /math to insert a macro anywhere on your page

🔒 Enterprise-Grade Security

Built on Atlassian Forge for maximum security and reliability:

Runs on Atlassian Infrastructure: No external dependencies or third-party servers
Access Control: Configure who can view and edit equations
User Whitelisting: Restrict equation editing to specific users or groups
Permission Management: Granular control over macro usage

🌗 Dark Mode Support

Perfect viewing experience in any environment:

Automatic Theme Detection: Equations adapt to your Confluence theme
Comfortable Viewing: Optimized contrast for both light and dark modes
Consistent Experience: Professional appearance regardless of theme preference

📊 Usage Analytics

Track and monitor equation usage across your instance:

Usage Statistics: See how many equations are being created
Adoption Metrics: Track macro usage over time
Administrative Insights: Understand how your team uses mathematical documentation

💡 Why Your Team Needs This

LaTeX Math for Confluence solves the challenge of documenting technical and mathematical concepts. Instead of using screenshots, external equation editors, or compromising with plain text, you get:

🎓 Perfect for Education

Course Materials: Create lecture notes, problem sets, and study guides
Research Documentation: Document mathematical proofs and research findings
Student Collaboration: Enable students to contribute mathematical content
Assignment Templates: Build reusable templates for mathematical coursework

🔬 Ideal for Technical Teams

Engineering Documentation: Document algorithms, formulas, and technical specifications
Data Science: Share statistical models, machine learning equations, and data analysis
Physics & Chemistry: Create scientific documentation with complex equations
Architecture Diagrams: Include mathematical specifications in design documents

📚 Enhanced Knowledge Sharing

Searchable Content: Unlike images, LaTeX equations remain searchable and accessible
Easy Updates: Edit equations directly without recreating images
Version Control: Track changes to equations just like any other Confluence content
Copy & Paste: Users can copy LaTeX code for reuse in other documents

🚀 Common Use Cases

Research & Development

Technical Specifications: Document mathematical models and algorithms
Research Papers: Collaborate on technical documentation before publication
Patent Documentation: Include precise mathematical descriptions
Scientific Reports: Create comprehensive technical reports with proper notation

Education & Training

Course Materials: Build complete courses with integrated mathematical content
Tutorial Documentation: Create step-by-step mathematical tutorials
Reference Guides: Maintain equation libraries and formula sheets
Practice Problems: Share problem sets with solutions

Engineering & Data Science

Algorithm Documentation: Explain complex algorithms with mathematical precision
Statistical Analysis: Document statistical methods and data models
Machine Learning: Share model architectures and optimization functions
Performance Metrics: Define KPIs and measurement formulas

Finance & Quantitative Analysis

Financial Models: Document pricing models and risk calculations
Investment Strategies: Share quantitative trading algorithms
Economic Analysis: Present economic models and forecasts
Actuarial Documentation: Create actuarial tables and calculations

🔗 Get Started Today

Ready to bring professional mathematical notation to your Confluence workspace?

👉 Install LaTeX Math for Confluence

Quick Start Guide

Install the App: Add LaTeX Math from the Atlassian Marketplace
Insert a Macro: Type /latex or /math on any Confluence page
Choose Your Style: Select inline (within text) or block (standalone) macro
Write LaTeX: Enter your LaTeX equation code
See It Live: Watch the real-time preview as you type
Save & Share: Publish your page with beautiful mathematical equations

Example LaTeX Snippets to Try

Quadratic Formula:

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

Pythagorean Theorem:

a^2 + b^2 = c^2

Integral:

\int_{a}^{b} f(x) \, dx

Matrix:

\begin{bmatrix}
a & b \\
c & d
\end{bmatrix}

📚 Learn More

Explore our comprehensive documentation to master all features:

👉 LaTeX Math for Confluence Documentation

Need Help?

Quick Reference: Browse our LaTeX syntax guide in the documentation
Support Team: Reach out via our support portal
FAQs: Check our documentation for common questions and solutions

✨ Transform Your Technical Documentation

Whether you're documenting complex algorithms, teaching advanced mathematics, or sharing scientific research, LaTeX Math for Confluence gives you the tools to communicate with precision and clarity.

Start creating beautiful equations today!

Have questions or feedback? We'd love to hear from you via our support portal. Your input helps us continue improving our apps to better serve your team's needs.

How Data Science Teams Document ML Models in Confluence

Yamuno — Thu, 23 Apr 2026 13:42:16 +0000

How Data Science Teams Document ML Models in Confluence

Most data science teams have the same documentation problem: the math lives somewhere else.

Loss functions in a Jupyter notebook. Model architecture equations in a Google Doc. Evaluation metrics in a Slack thread. Confluence ends up as a project tracker rather than a real knowledge base — because there was no good way to write math in it.

LaTeX Math for Confluence changes that. Here's how teams are using it to actually document their models.

The Problem with Screenshots and Plain Text

The two common workarounds both have obvious failure modes.

Screenshots look fine on day one. Then the model changes, the screenshot is wrong, and nobody updates it because re-exporting from LaTeX or Overleaf and re-uploading feels like too much work. Six months later, the page has equations that don't match the code.

Plain text approximations (loss = -sum(y * log(y_hat))) are readable to the author but lose precision fast. No Greek letters, no proper fractions, no summation notation. Anyone reading the doc has to mentally parse notation that doesn't match what they'd write on a whiteboard.

Documenting Models with LaTeX in Confluence

With LaTeX Math, you type /latex or /math on any Confluence page and get a live editor. Equations render in real time as you type, and you can choose inline (within a sentence) or block (standalone, centered) layout.

Here's how it maps to the kinds of things data science teams actually write.

Loss Functions

The cross-entropy loss for a classification model:

\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic})

Mean squared error:

\mathcal{L}_{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2

Binary cross-entropy:

\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]

These go inline in a model card, in a section right next to the architecture description and training configuration — all in one Confluence page that anyone on the team can find.

Activation Functions

Documenting why you chose a particular activation is easier when you can show it properly.

ReLU:

f(x) = \max(0, x)

Sigmoid:

\sigma(x) = \frac{1}{1 + e^{-x}}

Softmax (for a vector z of length K):

\text{softmax}(z_j) = \frac{e^{z_j}}{\sum_{k=1}^{K} e^{z_k}}

GELU (common in transformer models):

\text{GELU}(x) = x \cdot \Phi(x)

Evaluation Metrics

Precision and recall written in plain text are fine. Written as equations they're unambiguous:

\text{Precision} = \frac{TP}{TP + FP}
\qquad
\text{Recall} = \frac{TP}{TP + FN}

F1 score:

F_1 = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}

AUROC is harder to describe in words than in math:

\text{AUROC} = \int_0^1 \text{TPR}(t) \, d(\text{FPR}(t))

Regularisation and Optimisers

L2 regularisation added to a loss term:

\mathcal{L}_{reg} = \mathcal{L} + \lambda \sum_{j} w_j^2

Adam update rule — the kind of thing that should live in your training runbook:

m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t
\qquad
v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2

\hat{m}_t = \frac{m_t}{1 - \beta_1^t}
\qquad
\hat{v}_t = \frac{v_t}{1 - \beta_2^t}

\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t

Bayesian and Probabilistic Models

Teams doing probabilistic modelling or Bayesian inference often have the worst documentation problem — Bayes' theorem in a Slack message is a disaster. In Confluence it's clean:

P(\theta \mid X) = \frac{P(X \mid \theta) \, P(\theta)}{P(X)}

KL divergence between two distributions:

D_{KL}(P \| Q) = \sum_{x} P(x) \log \frac{P(x)}{Q(x)}

ELBO for variational inference:

\mathcal{L}(\phi, \theta) = \mathbb{E}_{q_\phi(z|x)} \left[ \log p_\theta(x|z) \right] - D_{KL}\left( q_\phi(z|x) \| p(z) \right)

What a Model Card Looks Like in Practice

A typical model card in Confluence might be structured like this:

Overview — what the model does, who it's for
Architecture — layer counts, attention heads, embedding dimensions (inline equations for shapes)
Training objective — loss function as a block equation
Optimiser — learning rate, weight decay, scheduler (formulas inline in a table)
Evaluation — metrics defined as equations, results as a table
Known limitations — plain text

With LaTeX Math, the equations in that document are live, editable, and match the actual implementation. When a team member updates the model and changes the loss function, they update the equation directly — no re-exporting, no new screenshots, no broken images.

Getting Started

Install LaTeX Math for Confluence from the Atlassian Marketplace. On any Confluence page, type /latex to insert a block equation or /math for an inline equation.

Full documentation is at LaTeX Math for Confluence docs.

Questions? Reach out via our support portal.

5 Things You Can Build with HTML Macro for Confluence

Yamuno — Thu, 23 Apr 2026 13:36:51 +0000

5 Things You Can Build with HTML Macro for Confluence

Confluence is a solid documentation platform. But the moment you need a colored status badge, a countdown to your launch date, or a table that users can actually sort — you hit a wall. Native macros only go so far.

HTML Macro for Confluence fills that gap. It lets you drop a full HTML/CSS/JS editor directly into any Confluence page. Live preview, CSP security controls, granular access permissions — and it runs entirely on Atlassian Forge with nothing sent to external servers.

Here are five concrete things teams are building with it right now.

1. Custom Status Badge / Traffic Light Indicator

The problem: Your project status page needs a RAG (Red/Amber/Green) indicator that's quick to read and easy for editors to update. The native Confluence status macro is limited, and color-coded text doesn't stand out enough for at-a-glance checks.

The solution: A simple HTML/CSS badge with a colored circle and a label. Editors change one word to flip the status.

<!-- HTML -->
<div class="rag-badge">
  <span class="dot green"></span>
  <span class="label">On Track</span>
</div>

/* CSS */
.rag-badge {
  display: flex;
  align-items: center;
  gap: 10px;
  font-family: sans-serif;
  font-size: 16px;
  font-weight: 600;
}

.dot {
  width: 18px;
  height: 18px;
  border-radius: 50%;
  display: inline-block;
  flex-shrink: 0;
}

.dot.green  { background-color: #22c55e; box-shadow: 0 0 8px #22c55e88; }
.dot.amber  { background-color: #f59e0b; box-shadow: 0 0 8px #f59e0b88; }
.dot.red    { background-color: #ef4444; box-shadow: 0 0 8px #ef444488; }

.label { color: #1e293b; }

Why it's useful: Swap green → amber → red on the dot class and update the label text. That's the entire update. No Confluence macros to reconfigure, no separate status apps to install. Engineers, PMs, and project leads can glance at a page and immediately know where things stand.

2. Embedded Countdown Timer

The problem: Your team has a product launch date, a sprint end, or a compliance deadline coming up. A static date in the page body gets ignored. Teams want something that actively reminds them how much runway is left.

The solution: A JavaScript countdown that calculates days, hours, and minutes remaining from a target date, updating every second.

<!-- HTML -->
<div class="countdown-wrapper">
  <div class="countdown-title">Launch Countdown</div>
  <div class="countdown-timer">
    <div class="unit"><span id="days">--</span><label>Days</label></div>
    <div class="unit"><span id="hours">--</span><label>Hours</label></div>
    <div class="unit"><span id="minutes">--</span><label>Minutes</label></div>
  </div>
</div>

/* CSS */
.countdown-wrapper { font-family: sans-serif; text-align: center; padding: 24px; background: #f8fafc; border-radius: 12px; }
.countdown-title { font-size: 14px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.08em; color: #64748b; margin-bottom: 16px; }
.countdown-timer { display: flex; justify-content: center; gap: 24px; }
.unit { display: flex; flex-direction: column; align-items: center; }
.unit span { font-size: 48px; font-weight: 700; color: #1e293b; line-height: 1; }
.unit label { font-size: 12px; color: #94a3b8; margin-top: 4px; text-transform: uppercase; letter-spacing: 0.06em; }

// JavaScript — set your target date here
const target = new Date("2026-05-01T09:00:00");

function tick() {
  const diff = target - new Date();
  if (diff <= 0) {
    document.querySelector(".countdown-timer").innerHTML = "<p>We're live!</p>";
    return;
  }
  document.getElementById("days").textContent    = Math.floor(diff / 86400000);
  document.getElementById("hours").textContent   = Math.floor((diff % 86400000) / 3600000);
  document.getElementById("minutes").textContent = Math.floor((diff % 3600000) / 60000);
}

tick();
setInterval(tick, 1000);

Why it's useful: Change one date string and you have a live countdown that works for any milestone. Sprint reviews, feature freezes, go-live dates — it's a passive but effective nudge every time someone opens the page.

3. Interactive Decision Tree for Runbooks

The problem: Runbooks and incident response guides are often long, linear documents. Engineers in the middle of an incident don't want to read paragraphs — they want to answer a question and be told exactly what to do next.

The solution: A clickable HTML/CSS decision tree that walks users through branching logic step by step. No external charting library required.

<!-- HTML -->
<div class="tree" id="tree">
  <div class="node active" id="q1">
    <p>Is the service returning errors?</p>
    <div class="choices">
      <button onclick="show('q1-yes')">Yes</button>
      <button onclick="show('q1-no')">No</button>
    </div>
  </div>
  <div class="node" id="q1-yes">
    <p>Are errors 5xx (server-side)?</p>
    <div class="choices">
      <button onclick="show('check-logs')">Yes</button>
      <button onclick="show('check-upstream')">No</button>
    </div>
  </div>
  <div class="node answer" id="check-logs">
    <p>Check application logs in Datadog. Look for OOM errors or unhandled exceptions. Page the on-call engineer if needed.</p>
    <button onclick="reset()">Start over</button>
  </div>
  <div class="node answer" id="check-upstream">
    <p>Likely a 4xx or gateway issue. Check upstream dependencies and API gateway logs.</p>
    <button onclick="reset()">Start over</button>
  </div>
  <div class="node answer" id="q1-no">
    <p>Service appears healthy. Check monitoring dashboards for latency spikes or queue depth issues.</p>
    <button onclick="reset()">Start over</button>
  </div>
</div>

/* CSS */
.tree { font-family: sans-serif; max-width: 480px; }
.node { display: none; padding: 20px; border: 1px solid #e2e8f0; border-radius: 10px; margin-bottom: 12px; background: #fff; }
.node.active { display: block; }
.node p { margin: 0 0 14px; font-size: 15px; color: #1e293b; font-weight: 500; }
.choices { display: flex; gap: 10px; }
button { padding: 8px 18px; border: none; border-radius: 6px; background: #6366f1; color: #fff; font-size: 14px; cursor: pointer; }
button:hover { background: #4f46e5; }
.answer { background: #f0fdf4; border-color: #86efac; }
.answer p { color: #166534; font-weight: 400; }
.answer button { background: #64748b; }

// JavaScript
function show(id) {
  document.querySelectorAll(".node").forEach(n => n.classList.remove("active"));
  document.getElementById(id).classList.add("active");
}
function reset() { show("q1"); }

Why it's useful: Runbook authors can build arbitrarily deep trees using just HTML — no Mermaid, no Lucidchart license needed. The tree lives inside the Confluence page, is searchable, and can be updated by anyone with access to the macro editor.

4. Custom Data Table with Sort and Filter

The problem: Confluence tables are static. You can't click a column header to sort, and there's no filter input. For any table with more than a dozen rows — vendor lists, feature matrices, environment configs — this is a real usability problem.

The solution: A vanilla JavaScript snippet that adds click-to-sort to any HTML table, plus a live filter input.

<!-- HTML -->
<div class="table-wrapper">
  <input id="filter" type="text" placeholder="Filter rows..." />
  <table id="data-table">
    <thead>
      <tr>
        <th>Service</th>
        <th>Owner</th>
        <th>Status</th>
        <th>SLA</th>
      </tr>
    </thead>
    <tbody>
      <tr><td>Auth API</td><td>Platform</td><td>Healthy</td><td>99.9%</td></tr>
      <tr><td>Billing</td><td>Payments</td><td>Degraded</td><td>99.5%</td></tr>
      <tr><td>Notifications</td><td>Growth</td><td>Healthy</td><td>99.0%</td></tr>
      <tr><td>Search</td><td>Platform</td><td>Healthy</td><td>99.9%</td></tr>
      <tr><td>Analytics</td><td>Data</td><td>Maintenance</td><td>98.0%</td></tr>
    </tbody>
  </table>
</div>

/* CSS */
.table-wrapper { font-family: sans-serif; }
#filter { width: 100%; padding: 8px 12px; margin-bottom: 12px; border: 1px solid #cbd5e1; border-radius: 6px; font-size: 14px; box-sizing: border-box; }
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th { background: #f1f5f9; padding: 10px 14px; text-align: left; cursor: pointer; user-select: none; border-bottom: 2px solid #e2e8f0; color: #475569; }
th:hover { background: #e2e8f0; }
td { padding: 10px 14px; border-bottom: 1px solid #f1f5f9; color: #1e293b; }
tr:hover td { background: #f8fafc; }
th.asc::after  { content: " ▲"; font-size: 11px; }
th.desc::after { content: " ▼"; font-size: 11px; }

// JavaScript
const table = document.getElementById("data-table");
const tbody = table.querySelector("tbody");
const headers = table.querySelectorAll("th");
let sortCol = -1, sortAsc = true;

headers.forEach((th, i) => {
  th.addEventListener("click", () => {
    if (sortCol === i) { sortAsc = !sortAsc; } else { sortCol = i; sortAsc = true; }
    headers.forEach(h => h.classList.remove("asc", "desc"));
    th.classList.add(sortAsc ? "asc" : "desc");
    const rows = Array.from(tbody.querySelectorAll("tr"));
    rows.sort((a, b) => {
      const av = a.cells[i].textContent.trim();
      const bv = b.cells[i].textContent.trim();
      return sortAsc ? av.localeCompare(bv) : bv.localeCompare(av);
    });
    rows.forEach(r => tbody.appendChild(r));
  });
});

document.getElementById("filter").addEventListener("input", function () {
  const q = this.value.toLowerCase();
  tbody.querySelectorAll("tr").forEach(row => {
    row.style.display = row.textContent.toLowerCase().includes(q) ? "" : "none";
  });
});

Why it's useful: Replace the <tbody> rows with your actual data and you have a fully sortable, filterable table with zero dependencies. Works for service registries, on-call rosters, feature flags, release checklists — anything that lives in a Confluence table but deserves better UX.

5. Branded Announcement Banner

The problem: HR needs to announce open enrollment. Marketing wants to flag a product launch to all readers of a space. The built-in Confluence info panel is functional but bland — it doesn't match company branding and blends into the page noise.

The solution: A CSS-styled announcement banner with a company-colored left border, an icon, a headline, and body text. Completely customizable.

<!-- HTML -->
<div class="announcement">
  <div class="announcement-icon">📣</div>
  <div class="announcement-body">
    <div class="announcement-title">Open Enrollment — Action Required</div>
    <div class="announcement-message">
      Benefits enrollment is open until <strong>April 30, 2026</strong>.
      Log in to Workday and complete your selections before the deadline.
      Contact <a href="mailto:hr@company.com">hr@company.com</a> with questions.
    </div>
  </div>
</div>

/* CSS */
.announcement {
  display: flex;
  align-items: flex-start;
  gap: 16px;
  padding: 18px 20px;
  border-left: 5px solid #6366f1;
  background: #eef2ff;
  border-radius: 0 10px 10px 0;
  font-family: sans-serif;
  max-width: 680px;
}

.announcement-icon {
  font-size: 24px;
  flex-shrink: 0;
  margin-top: 2px;
}

.announcement-title {
  font-size: 15px;
  font-weight: 700;
  color: #3730a3;
  margin-bottom: 6px;
}

.announcement-message {
  font-size: 14px;
  color: #1e293b;
  line-height: 1.6;
}

.announcement-message a {
  color: #6366f1;
  text-decoration: none;
  font-weight: 500;
}

.announcement-message a:hover { text-decoration: underline; }

Why it's useful: Change the border color and background tint to match your brand palette, swap in your own headline and message, and you have a polished callout that actually gets noticed. No graphic design skills needed, and the same template works for IT alerts, policy updates, and event announcements.

A Note on Security

Embedding HTML and JavaScript in a documentation platform is a responsibility that admins need to control. HTML Macro for Confluence gives you three Content Security Policy modes:

Block All — the strictest setting. No external resources (scripts, fonts, images) can load. This is the right default for pure HTML/CSS snippets like the badge and banner examples above.
Whitelist — you specify exactly which external domains are permitted. If your team uses Chart.js from a CDN or embeds a Google Map, you add those domains to the allowlist and nothing else gets through.
Allow All — fully permissive. Appropriate for tightly controlled internal environments where you trust every editor.

Combined with editor access control — which limits who can open the code editor in the first place — you can let most teams use the rendered output without ever exposing the source code.

Try It Free

All five of the examples above work today, without any paid tier, without any external server, and without leaving Confluence.

HTML Macro for Confluence is free on the Atlassian Marketplace. Install it, drop it into a page, and paste in one of the snippets above to see the live preview update as you type.

Install HTML Macro for Confluence — free on the Atlassian Marketplace

Have a use case we didn't cover? We'd love to hear what your team builds. Reach out through our support portal.

Embed Custom HTML, CSS & JavaScript in Confluence — Introducing HTML Macro for Confluence

Yamuno — Thu, 23 Apr 2026 13:36:38 +0000

Introducing HTML Macro for Confluence

We're thrilled to announce that HTML Macro for Confluence is now live on the Atlassian Marketplace — and it's free!

Confluence is great for documentation, but sometimes you need more than what native macros can offer. Now you can embed fully custom HTML, CSS, and JavaScript directly inside any Confluence page — interactive charts, branded sections, custom embeds, you name it.

What Is HTML Macro for Confluence?

HTML Macro for Confluence is a Forge-native Confluence Cloud app that lets you insert a rich code editor directly into any page. Write HTML, CSS, and JavaScript with syntax highlighting, see a live preview as you type, and publish polished interactive content — all without leaving Confluence.

Key Features

Code Editor with Live Preview

The macro opens a three-tab editor (HTML, CSS, JS) with syntax highlighting. A resizable split panel shows the rendered output in real time as you type — no more guessing how your code will look once saved.

Enterprise-Grade CSP Security

Security is built in, not bolted on. Admins choose from three Content Security Policy modes:

Block All — no external resources allowed (strictest, default)
Whitelist — only domains you explicitly approve can load resources
Allow All — unrestricted, for trusted internal environments

This means you can let teams use Chart.js, Google Maps, or YouTube embeds safely — by whitelisting only the domains you trust.

Editor Access Control

Not everyone on a page should be able to edit embedded code. HTML Macro lets admins whitelist specific users who can open the code editor. Everyone else sees only the rendered output — source code stays private.

Automatic iframe Height

The macro auto-adjusts its iframe height to match the content — no fixed heights to set, no awkward blank space below your widget.

Macro Usage Analytics

Admins get a dashboard showing every Confluence page using the HTML Macro across the entire instance, with space breakdowns and direct page links. Understand adoption and audit usage in seconds.

Runs Entirely on Atlassian Forge

HTML Macro for Confluence is 100% Forge-native. All content is stored inside Atlassian's infrastructure. Nothing is sent to external servers — ever.

What Can You Build?

Here are a few things teams are already building with HTML Macro for Confluence:

Interactive dashboards using Chart.js or D3.js
Branded internal landing pages with custom CSS layouts
Embedded maps via Google Maps or Leaflet
Video embeds (YouTube, Vimeo) with custom styling
Custom tables and data grids with sorting and filtering
Onboarding checklists and interactive forms
Countdown timers and status banners

If you can build it with HTML, CSS, and JavaScript — you can put it in Confluence.

Getting Started

Install the app from the Atlassian Marketplace
Open any Confluence page and type /HTML Macro
Write your HTML, CSS, and JavaScript in the editor
See the live preview update as you type
Save and publish — your content is live

Free on the Marketplace

HTML Macro for Confluence is available for free. Install it today and start building richer Confluence pages in minutes.

👉 Install HTML Macro for Confluence

👉 Read the Documentation

Questions or feedback? Reach out via our support portal — we'd love to hear what you build with it.

How to Import Markdown Files into Confluence (Step-by-Step Guide)

Yamuno — Thu, 23 Apr 2026 13:31:14 +0000

How to Import Markdown Files into Confluence

Confluence is where your team documents things. Markdown is where developers write things. The problem is they don't naturally talk to each other — pasting markdown into Confluence turns your beautiful formatting into a wall of symbols.

Markdown Importer for Confluence & Markdown Exporter bridges that gap. Here's exactly how to use it to get markdown into Confluence — whether that's a single file, a folder of docs, or an entire GitHub repository.

Option 1 — Import a Single Markdown File

Best for: a single README, a runbook, an architecture decision record, or any standalone document.

Open any Confluence space and navigate to where you want the page
Click Apps → Markdown Importer
Click Import Files and upload your .md or .mdx file
Preview the rendered output
Select the parent page (or leave it at the space root)
Click Import

Your page is created with all formatting intact — headings, tables, code blocks, images, and lists all convert cleanly.

Option 2 — Import a Folder of Markdown Files

Best for: importing a docs folder from a project, a wiki from GitHub/GitLab, or any set of related documents that form a hierarchy.

Zip your markdown folder (preserving the folder structure)
Open Markdown Importer from the Apps menu
Click Import Files and upload the ZIP
The importer reads your folder structure and maps it to a Confluence page hierarchy
Preview the page tree — reorder or exclude pages as needed
Select the parent page in Confluence
Click Import

The folder hierarchy becomes your Confluence page tree:

docs/
├── getting-started/
│   ├── index.md        → Getting Started (parent)
│   ├── installation.md → Installation (child)
│   └── quick-start.md  → Quick Start (child)
└── features/
    ├── index.md        → Features (parent)
    └── api.md          → API Reference (child)

Internal links between files are automatically converted to Confluence page links — cross-references stay intact.

Option 3 — Import from a GitHub or GitLab Repository

Best for: syncing developer documentation directly from source control into Confluence — keeping your /docs folder and your Confluence space in sync.

Open Markdown Importer from the Apps menu
Click Import from URL
Paste your GitHub or GitLab repository URL (or a specific folder URL)
The importer fetches your markdown files directly from the repo
Preview the page tree
Select the destination in Confluence
Click Import

This is the fastest path from a Git repo to Confluence — no need to clone locally, zip files, or manually copy content.

Option 4 — Import via REST API (Automated Pipelines)

Best for: CI/CD pipelines, documentation-as-code workflows, and teams that want to automatically sync docs on every commit.

The Markdown Importer exposes a REST API that lets you trigger imports programmatically. Add it to your CI pipeline and your Confluence pages update automatically whenever your docs change.

See the REST API documentation for full details.

What Gets Preserved

The importer handles the full range of standard markdown formatting:

Headings — H1–H6 map to Confluence heading levels
Text formatting — bold, italic, strikethrough, inline code
Tables — including alignment and header rows
Code blocks — with language and syntax highlighting
Lists — ordered, unordered, nested, and task lists with checkboxes
Images — uploaded as Confluence attachments and linked inline
Blockquotes — converted to Confluence info/note panels
Links — external URLs preserved; internal .md links converted to Confluence page links
Frontmatter — YAML frontmatter is parsed (title, date, author, tags can map to page properties)

Tips

Check your image paths. If your markdown references images with relative paths, make sure the images are included in your ZIP or accessible at the URL before importing.

Use frontmatter for page titles. If your files have title: in the YAML frontmatter, the importer uses that as the Confluence page title instead of the filename.

Import into a staging space first. For large imports, run it in a test space before hitting production. It's easy to re-import if anything looks off.

Bulk import is unlimited. There's no cap on how many pages you can import in one go — import an entire repository if you need to.

Getting Started

Install Markdown Importer for Confluence & Markdown Exporter from the Atlassian Marketplace — free to try.

Full documentation is at /docs/markdown-importer-for-confluence.

Questions? Reach out via our support portal.