---
title: "Discord Markdown: Format Messages Like a Pro (2025 Guide)"
description: "A complete reference for Discord Markdown — bold, italics, code blocks, spoilers, headers, lists, quotes, and the hidden tricks power users rely on every day."
date: "2025-11-20"
author: "Markdown Viewer Team"
tags: ["markdown", "discord", "formatting", "guide"]
cover: "/og.png"
---

Discord supports Markdown — but a slightly different flavor than GitHub or Notion. If you've ever typed `*bold*` and watched it render as italic, you know the pain.

This guide is the complete reference: every Markdown feature Discord supports, the quirks that trip up new users, and the tricks power users (community moderators, bot devs, gamers) use every day.

## What Markdown looks like in Discord

When you type Markdown in the Discord chat box and press Enter, Discord formats your message using a CommonMark-like flavor with a few additions and a few omissions.

The five most-used:

| You type           | Result        |
| ------------------ | ------------- |
| `**bold**`         | **bold**      |
| `*italic*`         | _italic_      |
| `__underline__`    | underline (Discord-specific!) |
| `~~strikethrough~~`| ~~strike~~    |
| `` `code` ``       | `code`        |

That table covers ~90% of everyday Discord formatting. The rest is in the details below.

## Bold, italic, and underline

The basics:

```
**bold text**
*italic text* or _italic text_
__underline text__
***bold italic***
__**bold underline**__
```

Two things that surprise new users:

1. **Underline uses double underscores.** In most Markdown flavors, `__text__` is bold. Discord uses it for underline.
2. **Italic uses single asterisks or single underscores.** Both work. Pick one and stick with it.

You can mix freely:

```
This is ***bold italic***, this is __**bold underline**__,
and this is ***__bold italic underline__***.
```

## Strikethrough

```
~~This is crossed out.~~
```

Same syntax as GFM. Useful for marking things as done or for jokes.

## Inline code and code blocks

Inline code uses single backticks:

```
Run the `/help` command for a list.
```

Multi-line code blocks use three backticks:

````
```
const greeting = "Hello, Discord!";
console.log(greeting);
```
````

Discord supports syntax highlighting if you specify a language:

````
```js
const greeting = "Hello, Discord!";
```
````

Languages Discord highlights well: `js`, `ts`, `py`, `bash`, `json`, `yaml`, `html`, `css`, `sql`, `cpp`, `rs`, `go`, `java`, `md`, `diff`. The list is shorter than GitHub's — when in doubt, use plain triple backticks.

## Headers (H1, H2, H3)

Discord added header support in 2023:

```
# Big header
## Medium header
### Small header
```

A few rules:

- Only three header levels (`#`, `##`, `###`).
- The space after the `#` is required.
- Headers don't work inside DMs in some older clients — use server channels.

In long posts (server rules, announcements), headers make the content **dramatically** easier to skim.

## Quotes

A single `>` at the start of a line is a quote block:

```
> This is a quoted line.
```

Three `>` quotes everything that follows:

```
>>> This and everything after
is part of the quote.
```

Discord's `>>>` is unusual — most Markdown flavors don't have it. Use it for replies or for callouts.

## Lists

Bulleted lists:

```
- Item one
- Item two
  - Sub-item
- Item three
```

Numbered lists:

```
1. First
2. Second
3. Third
```

Discord doesn't auto-renumber. If you write `1. 1. 1.`, that's what you'll see.

## Spoilers

A Discord exclusive: hide content behind a spoiler tag:

```
||spoiler text||
```

The text appears blacked out until clicked. Use for plot twists, surprise reveals, or rate-limited info.

You can spoil entire blocks, mixed with formatting:

```
||This is **bold** and _italic_ inside a spoiler||
```

Click-to-reveal works on every Discord client.

## Mentions

Not strictly Markdown, but worth covering:

| Type       | Syntax              |
| ---------- | ------------------- |
| User       | `@username` or `<@USERID>` |
| Channel    | `#channel-name` or `<#CHANNELID>` |
| Role       | `@role-name` or `<@&ROLEID>` |
| Everyone   | `@everyone`         |
| Here       | `@here`             |
| Slash command | `</command:ID>`   |

Discord clients auto-suggest most of these as you type `@` or `#`. The bracketed forms are useful for bots and webhooks that don't have access to the auto-suggestion.

## Custom emoji and reactions

Standard emoji shortcodes work:

```
:thumbsup: :rocket: :heart:
```

Server-specific custom emoji use the same syntax — Discord replaces them automatically. Animated emoji (Nitro feature) work the same way.

To **mention** a custom emoji without the image (in a code block, for example), wrap it in inline code:

```
`:thumbsup:` becomes :thumbsup:
```

## Time and date stamps

Discord has a special syntax for timestamps that respects each viewer's timezone:

```
<t:1700000000>            // November 14, 2023 10:13 PM
<t:1700000000:R>          // 2 years ago
<t:1700000000:F>          // Tuesday, November 14, 2023 10:13 PM
```

The number is a **Unix timestamp** (seconds since 1970). Suffixes:

- No suffix or `:f` → short date and time
- `:F` → full date and time
- `:d`, `:D` → short or long date
- `:t`, `:T` → short or long time
- `:R` → relative (e.g. "in 3 hours")

This is a lifesaver for international communities — everyone sees the time in their own timezone.

## Links

Auto-linking works for raw URLs:

```
Check out https://trymarkdownviewer.com for details.
```

Discord generates an **embed preview** automatically for most URLs. To suppress the preview, wrap the URL in angle brackets:

```
Check out <https://trymarkdownviewer.com> for details.
```

The link is still clickable but no embed appears below.

You can also use the standard Markdown link syntax — but **only in embeds and webhooks**, not in regular chat messages. In normal chat, `[text](url)` shows as literal text. This is one of Discord's biggest Markdown quirks.

## Headers + spoilers + code blocks together

You can combine most of these for rich posts. A typical "announcement" pattern:

```
# 🎉 Patch 2.5 is live

## What's new
- Spoiler tag now works in voice channels: ||top secret||
- Slash command improvements
- New **role colors**

## Known issues
> Voice channels may occasionally desync on Firefox.
> A fix is in progress.

## Commands

```bash
/help     # show help
/report   # report a bug
```
```

This kind of structured post looks dramatically more professional than a wall of plain text.

## Escaping Markdown

To show Markdown syntax **literally**, escape with a backslash:

```
\*not italic\*
\**not bold\**
```

Or wrap it in inline code:

```
`*not italic*`
```

This is useful when explaining Markdown to other users — meta, but common in community help channels.

## Limits and gotchas

A few things to know:

- **Message length:** 2,000 characters (4,000 with Nitro). Markdown counts toward the limit.
- **Code blocks count too.** A 1,800-character message with a fenced code block can push you over.
- **No tables.** Discord doesn't support GFM tables. If you need a table, take a screenshot or use a `code block` for monospaced alignment.
- **No images via Markdown.** Image upload is a separate UI affordance — `![](url)` doesn't work in chat.
- **No nested blockquotes.** A `>` inside another `>` is treated as part of the quoted content.

## Bot formatting (webhooks and embeds)

If you're writing a Discord bot, embeds give you **richer** formatting:

```json
{
  "embeds": [{
    "title": "Announcement",
    "description": "**Bold**, *italic*, [a link](https://example.com)",
    "color": 5814783,
    "fields": [
      { "name": "Build", "value": "`v2.5.1`", "inline": true },
      { "name": "Status", "value": "✅ green", "inline": true }
    ]
  }]
}
```

Inside an embed's `description` and `value`:

- Markdown links (`[text](url)`) **do** work.
- Headers (`#`, `##`, `###`) work in `description` since 2023.
- Mentions and timestamps work.
- Code blocks work.

The full embed reference is in the [Discord developer docs](https://discord.com/developers/docs/resources/channel#embed-object).

## Markdown tricks Discord power users love

A few patterns you'll see in well-run servers:

### 1. ASCII art borders

```
┌─────────────────────┐
│  Welcome to the server │
└─────────────────────┘
```

Wrap in a code block so the monospace font keeps it aligned.

### 2. Multi-line "ASCII tables"

Discord doesn't support real tables, but code-block alignment is a workable substitute:

```
| Build | Status | Notes        |
| ----- | ------ | ------------ |
| 2.5.1 | ✅     | stable       |
| 2.5.2 | ⚠️     | beta         |
```

Inside a code block this renders with consistent column widths.

### 3. Folded long announcements with quotes

Lead with the headline, then use `>` quotes for context — readers can skim the headline first:

```
**New: voice channel screen sharing**

> We've added full-screen sharing to voice channels.
> It's available now for all users — no Nitro required.
```

### 4. Hidden "ping list" using spoiler tags

Tag everyone who needs to see something without spamming the chat with mentions:

```
Update for our build squad:
|| @builder1 @builder2 @builder3 ||
```

Only the relevant people get notified.

## Common Discord Markdown mistakes

**1. Forgetting that `__` is underline.** In every other Markdown flavor, `__text__` is bold.

**2. Using `[text](url)` in chat.** It renders as literal text. Use bare URLs in chat or use the embed for rich links.

**3. Trying to embed images with Markdown syntax.** Use the upload affordance instead.

**4. Long code blocks pushing over the 2000-char limit.** Split them, or screenshot.

**5. Inconsistent escape characters.** Discord ignores most escape sequences in normal chat — wrap in code for the most reliable literal display.

## Try it before you post

Want to preview your Discord post before hitting send? Paste it into the [Markdown editor](/editor) — most Discord Markdown features render the same way. The biggest differences:

- Discord uses `__` for underline (we render it as bold).
- Discord supports `||spoilers||` (we render them as plain text).
- Discord auto-resolves `<t:1700000000>` to a localized timestamp (we render them as text).

For everything else — bold, italic, code blocks, lists, quotes, headers — what you see in our preview is what your Discord audience sees.

## Related articles

- [Markdown cheat sheet](/blog/markdown-cheat-sheet) — every Markdown feature on a single page
- [Markdown vs HTML](/blog/markdown-vs-html) — when each is the right tool
- [Markdown syntax guide](/blog/markdown-syntax-guide) — CommonMark and GFM, end to end

## Quick reference

```
**bold**                          Bold
*italic* or _italic_              Italic
__underline__                     Underline (Discord-specific)
~~strikethrough~~                 Strike
`inline code`                     Inline code
``` … ```                         Code block
```lang … ```                     Code block with highlighting
> quote                           Single-line quote
>>> quote                         Multi-line quote
# H1, ## H2, ### H3               Headers
- item                            Bulleted list
1. item                           Numbered list
||spoiler||                       Spoiler
<t:UNIX>                          Timestamp
<@USERID>                         User mention
<#CHANNELID>                      Channel mention
<https://url>                     Link without embed preview
```

That's the full Discord Markdown toolkit. With these patterns your messages will look better than 95% of the server.
