Skip to main content

Obsidian Markdown Formatting

Obsidian extends standard Markdown with wikilinks, embeds, block references, tags, and callouts. Every syntax — with copy-ready examples.

All standard CommonMark works. The features below are what make Obsidian different from GitHub, Notion, or any other Markdown editor.

What makes Obsidian different

Three Obsidian-only features you can't get in plain Markdown

1. Wikilinks

[[Note Title]]

Link by note title. Auto-completes, auto-resolves, and creates the note if it doesn't exist yet.

2. Embeds

![[Note]]

Transclude a whole note, a section, a single block, or any media file inline.

3. Block references

[[Note#^id]]

Link to a single paragraph or list item — Obsidian generates the ID for you.

Embeds (Transclusion)

Prepend any wikilink with ! to embed the target inline. Obsidian renders the embedded content directly inside the current note — text, images, audio, video, and PDFs all work.

Embed a full note

Bang prefix turns a wikilink into a transclusion — the target note's content is rendered inline in the current note.

Obsidian
![[Note Title]]
Embed a section

Embeds only the content under a specific heading until the next same-level heading.

Obsidian
![[Note Title#Heading]]
Embed a single block

Embeds one paragraph, list item, or table row identified by its block ID.

Obsidian
![[Note Title#^block-id]]
Embed an image

Embeds images stored in the vault. Use a pipe to set width: ![[image.png|400]] (in pixels).

Obsidian
![[image.png]]
Embed audio, video, or PDF

Obsidian embeds .mp3/.mp4/.webm/.pdf inline with native HTML players.

Obsidian
![[video.mp4]]

Block References

Tag any paragraph, list item, or table row with a unique block ID, then link or embed it from anywhere. Obsidian generates the ID for you when you Ctrl/Cmd-drag a reference into a target note.

Define a block ID, then link to it
This paragraph has a block ID. ^my-quote

[[Other Note#^my-quote]]
![[Other Note#^my-quote]]

^my-quote at the end of a line marks that line as a referenceable block.

[[Other Note#^my-quote]] links to that block.

![[Other Note#^my-quote]] embeds the block inline.

Block IDs must be unique within a single note.

Tags

Tags are vault-wide labels for organizing and searching notes. They appear in the Tags pane, the graph view, and search queries (tag:#project).

Inline tag

A # immediately followed by text (no space) becomes a tag. Tags are searchable, filterable, and graph-visible.

#project
Nested tag

Slashes create nested tag hierarchies. Searching #project also matches all children.

#project/research/draft
Tags with numbers

Numbers and dashes are allowed. Must contain at least one non-numeric character, otherwise Obsidian treats it as a heading reference.

#2026-Q2
Tags in frontmatter

YAML frontmatter tags work the same as inline tags but live at the top of the file. No # prefix in frontmatter.

---
tags:
  - project
  - research
---

Callouts

Obsidian callouts use the same > [!type] syntax as GitHub alerts, but Obsidian supports 13 built-in types and lets you make them collapsible by appending + (open) or - (closed).

[!note]
> [!note]
> Default callout. Use for general notes and side commentary.
Renders in Obsidian as
Note

Default callout. Use for general notes and side commentary.

[!tip]aliases: hint, important
> [!tip]
> Helpful advice or shortcuts. Aliases: hint, important.
Renders in Obsidian as
Tip

Helpful advice or shortcuts. Aliases: hint, important.

[!success]aliases: check, done
> [!success]
> Positive outcomes or completed work. Aliases: check, done.
Renders in Obsidian as
Success

Positive outcomes or completed work. Aliases: check, done.

[!warning]aliases: caution, attention
> [!warning]
> Cautions or risks. Aliases: caution, attention.
Renders in Obsidian as
Warning

Cautions or risks. Aliases: caution, attention.

[!danger]aliases: error
> [!danger]
> Critical hazards. Aliases: error.
Renders in Obsidian as
Danger

Critical hazards. Aliases: error.

All 13 callout types (plus aliases)
[!note]
[!tip]

also: [!hint], [!important]

[!success]

also: [!check], [!done]

[!warning]

also: [!caution], [!attention]

[!danger]

also: [!error]

[!quote]

also: [!cite]

[!bug]
[!todo]
[!abstract]

also: [!summary], [!tldr]

[!info]
[!example]
[!failure]

also: [!fail], [!missing]

Foldable callouts
> [!note]+ Title (opens by default)
> Click the chevron to collapse.

> [!warning]- Title (closed by default)
> Click the chevron to expand.

Append + after the type to make a callout collapsible and open by default.

Append - to make it collapsible and closed by default.

Add a title after the type: > [!note] Custom title

Highlights

Wrap text in double equals signs (==text==) to highlight it. Obsidian renders this as yellow-highlighted text. This is not part of standard CommonMark — GitHub, Notion, Reddit, Slack, and Discord all render it as literal text.

Highlight syntax
This sentence has ==highlighted text== in the middle.
This sentence has highlighted text in the middle.

Math (KaTeX)

Inline math uses single $...$. Block math uses double $$...$$ on their own lines. Obsidian uses KaTeX, the same engine GitHub uses, so most LaTeX syntax renders identically across both platforms.

Inline math
The Pythagorean theorem is $a^2 + b^2 = c^2$.
The Pythagorean theorem is a2 + b2 = c2.
Block math
$$
\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}
$$
Σ (n=1 to ∞) 1/n² = π² / 6

Comments

Wrap text in double percent signs (%%hidden%%) to hide it from Reading view and Live Preview. The text is still visible in Source mode and is preserved in the file. Obsidian-only — every other Markdown renderer treats it as literal text.

Inline and block comments
This paragraph is %%hidden inline%% visible.

%%
This whole block is
hidden in Reading view.
%%

This paragraph is visible.

(The block comment renders as nothing in Reading view, but the text is preserved in Source mode.)

YAML Frontmatter

Frontmatter is YAML metadata at the very top of a note, fenced by ---. Obsidian reads several special keys (tags, aliases, cssclasses, publish), and arbitrary key/value pairs are surfaced to Dataview and templater plugins.

Common frontmatter keys
---
title: My Note
tags:
  - project
  - research
aliases:
  - "Project Alpha"
  - "Alpha Notes"
cssclasses:
  - wide-page
author: Andy
date: 2026-05-25
---

# Note body starts here

tags — list, no # prefix

aliases — alternative names that resolve wikilinks

cssclasses — applied to the note's container in Reading view

publish — true/false for Obsidian Publish

Any other key — accessible via the Properties view and Dataview queries

Mermaid Diagrams

Open a fenced code block with ```mermaid and write standard Mermaid syntax. Obsidian ships with Mermaid built in — no plugin required. Flowcharts, sequence, class, state, gantt, and pie diagrams all render in Reading view and Live Preview.

Flowchart example
```mermaid
flowchart LR
  A[Start] --> B{Has tag?}
  B -- Yes --> C[Index it]
  B -- No --> D[Skip]
  C --> E[Done]
  D --> E
```

Reading view vs Live Preview vs Source mode

Obsidian has three editing modes. Some syntax behaves differently depending on which mode you're in — knowing the difference saves a lot of confusion.

FeatureSource modeLive PreviewReading view
EditableYesYesNo
Renders bold/italic/headingsNo (raw)Yes (in place)Yes (rendered)
Renders wikilinksNoYesYes
Renders embeds (![[Note]])NoYesYes
Shows comments (%%text%%)Yes (visible)No (hidden)No (hidden)
Shows raw block IDs (^id)YesPartialHidden
Mermaid diagrams renderNoYesYes
Math ($...$) rendersNoYes (on cursor leave)Yes
Default for new notesDefaultToggle Cmd/Ctrl+E

Toggle between Live Preview and Reading view with Cmd/Ctrl + E. Switch to Source mode in Settings → Editor → Default editing mode.

Standard Markdown Still Works

Everything from CommonMark and GFM works in Obsidian: headings, lists, tables, code blocks, task lists, strikethrough, links, and images. Here's a quick example.

Standard Markdown in Obsidian
# Heading

**Bold** and *italic* text.

- [x] Task one
- [ ] Task two

| Col A | Col B |
|-------|-------|
| 1     | 2     |

Heading

Bold and italic text.

  • Task one
  • Task two
Col A Col B
1 2

Common Mistakes

The five most common Obsidian-specific gotchas.

Don't

[[note.md]]

Do

[[note]]

Wikilinks do not include the .md extension. Adding it works but creates a literal filename match that may not resolve.

Don't

[[Note Title (with parens)]]

Do

Use the [[Note Title \(with parens\)]] escape or rename the note

Parentheses in note titles confuse the wikilink parser. Either escape them with backslashes or simplify the title.

Don't

# tag

Do

#tag

No space between # and the tag text. A space turns it into a heading instead.

Don't

[[Note]] inside `code`

Do

Wrap normally — code spans suppress wikilink parsing

Wikilinks inside inline code or code blocks render as literal text. Use this intentionally when documenting wikilink syntax.

Don't

Block ID on a separate line

Do

Block ID at the end of the target line: A paragraph. ^my-id

Block IDs must be on the same line they tag. A standalone ^my-id on its own line is treated as text.

Quick Reference

Every Obsidian-flavored Markdown feature at a glance.

Syntax / FeatureWorks?Notes
Standard CommonMark (bold, italic, lists)YesAll CommonMark syntax works in every Obsidian view mode.
GFM Tables (| --- |)YesNative support — both Live Preview and Reading view render tables.
GFM Task lists (- [ ])YesRenders as interactive checkboxes. Clicking toggles the state and saves the file.
GFM Strikethrough (~~text~~)YesDouble tildes only. Single tildes render literally.
Wikilinks [[Note]]YesObsidian-specific. The signature feature for linking notes inside a vault.
Embeds ![[Note]]YesTransclude another note, image, audio, video, or PDF inline.
Block references ^block-idYesAppend ^id to a line to make it linkable as a specific block.
Tags (#tag, #parent/child)YesInline tags and YAML frontmatter tags both index in the Tags pane and graph view.
Highlights (==text==)YesRenders as yellow-highlighted text. Not part of CommonMark.
Comments (%%hidden%%)YesObsidian-only. Hidden in Reading view, visible only in Source mode.
Callouts (> [!note])YesSame syntax as GitHub alerts, plus more types: tip, success, warning, danger, quote, bug, todo, abstract, info, example, failure.
Math ($...$ and $$...$$)YesKaTeX renders inline and display math. Same syntax as GitHub but Obsidian uses single $ for inline (no requirement for surrounding non-whitespace).
Mermaid diagrams (```mermaid)YesBuilt in. Flowcharts, sequence, gantt, class diagrams all render in Reading view.
Footnotes ([^1])YesBoth reference and inline (^[note]) styles are supported.
YAML frontmatterYesNative. Used for tags, aliases, cssclasses, publish, and plugin metadata.
HTML pass-throughYesMost HTML tags render. <iframe>, <video>, and <audio> work; <script> is stripped.

Frequently Asked Questions

Does Obsidian use standard Markdown?

Yes — Obsidian is built on top of CommonMark with most GitHub-Flavored Markdown extensions (tables, task lists, strikethrough). On top of that, Obsidian adds its own features: wikilinks ([[Note]]), embeds (![[Note]]), block references (^block-id), tags (#tag), highlights (==text==), comments (%%hidden%%), and callouts (> [!note]). Standard Markdown files written outside Obsidian render correctly inside the vault.

What is the difference between [[wikilinks]] and [Markdown](links)?

Wikilinks are an Obsidian convention that lets you link by note title without writing the full path: [[Note Title]] auto-resolves to the note. Standard Markdown links use [text](path/to/note.md) and require the explicit path. Wikilinks are easier to write inside a vault, but they don't render outside Obsidian without a converter. You can switch the default in Settings → Files & Links → Use [[Wikilinks]].

How do I create a block reference in Obsidian?

Hover over any paragraph, list item, or table row, hold the Ctrl/Cmd key, and drag-select to a new location. Obsidian auto-generates a block ID. Or write one manually by appending ^block-id (a caret followed by an alphanumeric identifier) to the end of the target line, then link to it with [[Note Title#^block-id]].

What are the differences between Reading view, Live Preview, and Source mode?

Source mode shows the raw Markdown — no rendering. Live Preview (the default since Obsidian 0.13) renders syntax inline as you type, so you see bold, headings, links, and embeds rendered while still being able to edit. Reading view renders the document like a published web page with no editing affordances. Some features behave differently: comments (%%hidden%%) appear only in Source mode, and some plugins only render in Reading view.

How do tags work in Obsidian?

Type # immediately followed by alphanumeric text (no space). Tags are case-insensitive, can be nested with slashes (#project/research), and are indexed across the vault. They show up in the Tags pane, the graph view, and search queries. You can also declare tags in YAML frontmatter under a tags: key — both work interchangeably.

Can I use HTML in Obsidian notes?

Yes — most HTML tags pass through and render. This includes <iframe>, <video>, <audio>, and styled <div>s. <script> tags are stripped for security. HTML is commonly used in Obsidian for things Markdown can't express: underline (<u>text</u>), colored text (<span style="color:red">), centering (<div align="center">), and image sizing (<img width="300">).

How do I create callouts in Obsidian?

Callouts use the same syntax as GitHub alerts: a blockquote starting with [!type] on the first line. For example, > [!warning] creates a warning callout. Obsidian supports 13 built-in types (note, tip, success, warning, danger, info, quote, bug, todo, abstract, example, failure, question). You can also fold callouts by adding a + (open by default) or - (closed) after the type, e.g. > [!note]-

Does Obsidian support Mermaid diagrams?

Yes — Mermaid is built in. Open a code block with ```mermaid and write standard Mermaid syntax: flowcharts, sequence diagrams, class diagrams, state diagrams, gantt charts, and pie charts all render in Reading view and Live Preview. No plugin required.

What is YAML frontmatter in Obsidian?

Frontmatter is a YAML block at the very top of a note, between two --- delimiters. Obsidian uses it for metadata: tags, aliases (alternative names for the note), cssclasses (custom styling), publish (Obsidian Publish), and arbitrary key/value properties accessible to Dataview and other plugins. Properties view (the GUI editor) reads and writes the same YAML directly.

Learn More Markdown

Obsidian builds on top of standard Markdown. Compare it to other platforms and Markdown flavors: