Skip to main content

Slack Markdown & Text Formatting

Every Slack formatting syntax with copy-ready examples — and which of Slack's three formatting surfaces you are actually typing into, because they do not share a syntax.

Short answer

Slack's own format is mrkdwn, which is not Markdown: *bold*, _italic_, ~strike~, <url|text>, and no lists, headings or tables at all. The message box you type in uses the same single-character markup (plus [text](url) links), a toolbar, and shortcuts like ⌘B / Ctrl+B. That is two of three surfaces. The third is different: since 2025 an app can send a Block Kit markdown block that takes real standard Markdown, where **bold** is bold and headings, lists, tables, task lists and syntax-highlighted code all work.

Where Markdown Works in Slack

Almost every “why is my Slack formatting broken” question is really this question. Slack has three places text gets formatted, and each one parses a different syntax.

1. The composer

Typing in Slack

A formatting toolbar and shortcuts by default. Typed markup is Slack's own: *bold*, _italic_, ~strike~, plus [text](url) links.

2. mrkdwn

The API message format

The text field and every mrkdwn text object in Block Kit. The strict one: single asterisks, angle-bracket links, no lists or headings.

3. markdown block

Standard Markdown, for apps

A Block Kit block that takes ordinary Markdown and converts it itself. The only surface with tables, task lists and highlighted code.

Slack formatting syntax by surface: message composer, mrkdwn, and the Block Kit markdown block
FeatureComposermrkdwn (API)markdown block
Bold*bold* or ⌘B*bold***bold**
Italic_italic_ or ⌘I_italic_*italic* or _italic_
Strikethrough~strike~ or ⌘⇧X~strike~~~strike~~
Underline⌘U — no syntaxNot supportedNot supported
Link[text](url) or ⌘⇧U<url|text>[text](url)
Inline code`code` or ⌘⇧C`code``code`
Code block``` or ⌘⌥⇧C``` — no highlighting```python — highlighted
Blockquote> quote or ⌘⇧9> quote> quote
Bulleted list* then space, or ⌘⇧8Not supported- item
Numbered list1. then space, or ⌘⇧7Not supported1. item
HeadingNot supportedNot supported# Heading
TableNot supportedNot supported| Col | Col |
Task listNot supportedNot supported- [ ] task
DividerNot supportedNot supported---
ImageUpload or pasteNot supported![alt](url) → link text
The trap: standard Markdown pasted from GitHub or a chatbot uses **bold**, which is not Slack's bold in the composer or in mrkdwn. Going the other way, a [text](url) link that works in the composer shows up as literal brackets in a webhook payload, and moving mrkdwn into a markdown block turns every *bold* into italic.

Slack Text Formatting (mrkdwn)

This is the syntax that makes Slack different from every other Markdown, and it is also what Slack documents for typing in the message box. Because most renderers get it wrong, the right-hand panel below shows what Slack actually displays rather than a Markdown preview.

Bold — single asterisks

Slack uses one asterisk for bold. Two asterisks stay literal in mrkdwn.

mrkdwn
*bold text*
How it looks in Slack
bold text
Italic — single underscores

Underscores around the text. Asterisks mean bold in mrkdwn, not italic.

mrkdwn
_italic text_
How it looks in Slack
italic text
Strikethrough — single tildes

One tilde each side. The GitHub-style ~~double tilde~~ is not mrkdwn.

mrkdwn
~strikethrough~
How it looks in Slack
strikethrough
Bold + italic combined

Nest underscores inside asterisks. mrkdwn has no triple-marker shortcut.

mrkdwn
*_bold italic_*
How it looks in Slack
bold italic
Why underscores are the safer habit: _italic_ means italic in mrkdwn and in standard Markdown. The asterisk is the character that flips meaning between the two, so text written with underscores survives being moved between surfaces.

Standard Markdown in Slack: the markdown block

Slack introduced a Block Kit markdown block on 3 February 2025 and widened it on 6 March 2026 with tables, task lists, dividers, syntax-highlighted code blocks and variable-sized headers. It takes standard Markdown and does the conversion to Slack's internal format itself — so inside one, **bold** is correct and *bold* means italic, exactly backwards from mrkdwn. It works in messages only (not modals or App Home), and Slack notes that one markdown block may come back as several blocks after translation.

Slack's own stated reason for it is AI: when an LLM hands your app Markdown, a markdown block lets Slack translate it instead of you writing a converter. If you are formatting model output for Slack, this is the block to reach for — see our Markdown for AI guide for the wider pattern.

A markdown block in a message payload
{
  "blocks": [
    {
      "type": "markdown",
      "text": "## Deploy finished\n\n- [x] tests green\n- [ ] changelog\n\n| env | status |\n| --- | ------ |\n| prod | green |"
    }
  ]
}
Emphasis follows CommonMark, not mrkdwn — two asterisks for bold
**bold**, *italic*, ~~strikethrough~~ and `inline code`
Preview
Headers work. Slack's reference says every level renders at the same size
# Header 1
## Header 2
### Header 3
Preview
Ordered and unordered lists, which plain mrkdwn cannot do at all
- first item
- second item
  - nested item

1. first step
2. second step
Preview
Task lists render as real checkboxes (added March 2026)
- [x] shipped the release notes
- [ ] update the changelog
Preview
Tables — the single biggest thing mrkdwn has never been able to do
| Environment | Status |
| ----------- | ------ |
| production  | green  |
| staging     | red    |
Preview
Three hyphens render a horizontal divider
Above the line

---

Below the line
Preview

Also available: markdown_text

chat.postMessage takes a markdown_text argument that accepts the same Markdown without building a block array. Slack's docs are explicit that it must not be combined with blocks or text, and caps it at 12,000 characters. The streaming method chat.startStream takes it too.

Two limits worth knowing

Slack's block reference says every heading level renders at the same size, so # and ###### look identical, though the March 2026 changelog lists “variable-sized headers”. Preview before relying on a hierarchy. And ![alt](url) does not embed an image — Slack turns it into hyperlink text. Use an image block for a real image.

Mentions and Special Tokens

Mentions are IDs wrapped in angle brackets, not display names. The composer autocompletes @name into the right ID for you; an API message has to arrive with the ID already in it, or it is just text and nobody gets notified. Slack recommends the explicit form precisely because names change.

Mention a user

The member ID, never the display name. From an app it only notifies people already in the channel.

mrkdwn
<@U012AB3CD>
How it looks in Slack
@username
Mention a channel

The channel ID. Slack fills in the current channel name when it renders.

mrkdwn
<#C123ABC456>
How it looks in Slack
#general
Mention a user group

The user-group ID after a caret. Renders as the group's handle.

mrkdwn
<!subteam^S0NHM1FH4>
How it looks in Slack
@team-name
Notify active members

Only pings people currently active in the channel.

mrkdwn
<!here>
How it looks in Slack
@here
Notify the whole channel

Pings every member. <!everyone> exists too, and only works in #general.

mrkdwn
<!channel>
How it looks in Slack
@channel
A timestamp in every reader's own timezone

Rendered in the timezone of the reader's device. The text after the pipe is the fallback.

mrkdwn
<!date^1392734382^{date_short} at {time}|Feb 18, 2014 at 6:39 AM>
How it looks in Slack
Feb 18, 2014 at 6:39 AM

Lists

Lists exist on two of Slack's three surfaces. In the composer, type * or 1. followed by a space and Slack builds a rich-text list as you go. In a markdown block, ordinary - item syntax renders properly. Plain mrkdwn has no list syntax at all — Slack's docs suggest mimicking one with hyphens and newlines, which is exactly as good as it sounds.

Unordered list in a markdown block (in the composer, start the line with * and a space)
- first item
- second item
- third item
Preview
Ordered list in a markdown block (in the composer, type 1. and a space)
1. first step
2. second step
3. third step
Preview

Sending a real list from an app

A markdown block is the short route. For full control over indentation and numbering, build a rich_text block with rich_text_list elements.

What does not work

Posting { "text": "- one\n- two" } gives you two lines of plain text that start with hyphens, not a list. mrkdwn does not render bullets, indentation or numbering.

Headings

Headings are the thinnest part of Slack formatting. There is no heading button in the composer toolbar and no keyboard shortcut for one; mrkdwn leaves # as a literal character; and a markdown block does accept # through ######, but Slack's block reference says every level renders at the same size, so the hierarchy you write may not be the hierarchy readers see. (Slack's March 2026 changelog does list “variable-sized headers”; the reference has not caught up, or the two disagree.)

For an app that needs one visually distinct title, the Block Kit header block is the reliable answer — it is a structural block rather than a piece of text formatting.

A header block above a body of mrkdwn
{
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "Deploy finished" }
    },
    {
      "type": "section",
      "text": { "type": "mrkdwn", "text": "Shipped by <@U012AB3CD> at *09:41*." }
    }
  ]
}

Note the mixture: a header block takes plain_text only, so no formatting is parsed inside it, while the section below it is mrkdwn and so uses single asterisks. See Markdown headings for how the syntax behaves everywhere else.

Slack Markdown Tables

“Slack does not support tables” was true for a decade and is now out of date. There are three answers, depending on who is sending the message.

A pipe table inside a markdown block — supported since March 2026
| Service | Owner | Status |
| ------- | ----- | ------ |
| api     | Dana  | green  |
| web     | Ravi  | amber  |
Preview
Alignment colons work the same as GitHub-flavored Markdown
| Left | Center | Right |
| :--- | :----: | ----: |
| a    | b      | c     |
Preview

From an app, quickly

Put a pipe table in a markdown block. Slack renders it as a real table, alignment colons included.

From an app, with control

The Block Kit table block, added 14 August 2025: up to 100 rows, 20 cells per row and 10,000 characters, with per-column alignment and wrapping. Since 20 May 2026 the data_table block adds sorting, filtering and pagination.

Typing by hand

Still no table. Paste the rows into a code block so the monospace font holds the columns together, or share a canvas instead.

Need the pipe syntax itself? Our Markdown tables guide covers alignment and escaping, and the table generator builds one you can drop straight into a markdown block.

Quotes and Code Blocks

These are the constructs where all three surfaces agree, with one exception: a language identifier on a code fence is honoured only inside a markdown block. Elsewhere nothing is highlighted, and since mrkdwn treats everything after the opening backticks as code, the language name can show up as a literal first line.

Blockquote — one > at the start of the line
> This line is quoted.
Preview
Multi-line quote — start every quoted line with >
> Line one of the quote.
> Line two continues it.
Preview
Inline code — single backticks, identical everywhere
`inline code` stays monospaced
Preview
Code block — triple backticks on every surface
```
function hello() {
  return "world";
}
```
Preview
Language hint — highlighted inside a markdown block only
```python
print("hello")
```
Preview
Inline code wins: Slack's docs state that text inside inline code takes no other formatting. Wrapping something in backticks is the simplest way to stop Slack from interpreting the asterisks and underscores in it.

The Composer: Shortcuts and the Markup Preference

By default the composer is WYSIWYG: you format with the toolbar or a shortcut and see the result as you type. The toolbar offers bold, italic, underline, strikethrough, code, block quote, code block and both list types, and the formatting icon in the message field hides or shows it. If your toolbar has vanished, that icon or the preference below is why.

Slack also ships a preference that turns typing into markup instead: click your profile picture, then Preferences → Advanced, and check “Format messages with markup” under Input options. The toolbar disappears and formatting is applied only after the message is sent. The markup is Slack's own, not standard Markdown: *bold*, _italic_, ~strike~, `code`, >quote, triple backticks for a code block, and [text](url) for a link.

The preference has two side effects Slack documents and people rarely expect: automatic list formatting is turned off, and pasted messages arrive as plain text. That last one is a feature if you paste code and snippets all day.

Slack message formatting keyboard shortcuts
FormattingMacWindows / Linux
Bold⌘ BCtrl B
Italic⌘ ICtrl I
Underline⌘ UNot documented
Strikethrough⌘ ⇧ XCtrl ⇧ X
Inline code⌘ ⇧ CCtrl ⇧ C
Code block⌘ ⌥ ⇧ CCtrl Alt ⇧ C
Blockquote⌘ ⇧ 9Ctrl ⇧ 9
Bulleted list⌘ ⇧ 8Ctrl ⇧ 8
Ordered list⌘ ⇧ 7Ctrl ⇧ 7
Link⌘ ⇧ UCtrl ⇧ U
Apply markdown formatting⌘ ⇧ FCtrl ⇧ F
Undo formatting⌘ ZCtrl Z
Underline is composer-only. ⌘U applies it, but there is no markup to type and no mrkdwn or markdown-block equivalent. Standard Markdown has the same gap, which our underline guide covers in full.

Escaping

Because mrkdwn builds links, mentions and date tokens out of angle brackets, three characters have to be escaped as HTML entities when an app sends mrkdwn. The composer handles this for you; a webhook payload does not.

Characters that must be escaped in Slack mrkdwn
CharacterSend insteadWhy
&&amp;Slack reads a bare & as the start of an HTML entity.
<&lt;Opens a link, mention or date token.
>&gt;Closes a link, mention or date token.

Encode only these three characters, not the whole string: Slack decodes nothing else, so a fully HTML-escaped message arrives with its entities showing. Inside a markdown block the rule is the ordinary Markdown one instead: a backslash before the character, so \*not italic\* keeps its asterisks. And to switch parsing off wholesale, set mrkdwn: false on a message, use a plain_text object inside a block, or set verbatim: true to keep formatting but stop Slack auto-linking names.

Common Mistakes

Every one of these comes from applying one surface's rules to another.

Does not work

**bold** in an API `text` field

Use instead

*bold*
Plain mrkdwn uses one asterisk. Two asterisks stay literal — unless you move the text into a markdown block, where **bold** is correct and *bold* means italic.

Does not work

**bold** typed in the Slack message box

Use instead

*bold* or ⌘B
The composer's markup is Slack's own, not standard Markdown: Slack documents one asterisk for bold, underscores for italic and one tilde for strikethrough. Double asterisks are markdown-block syntax.

Does not work

~~strikethrough~~ in mrkdwn

Use instead

~strikethrough~
mrkdwn and the composer use a single tilde. The double tilde is markdown-block syntax.

Does not work

[click here](https://example.com) in a section block

Use instead

<https://example.com|click here>
A mrkdwn text object needs the angle-bracket form. Standard link syntax is for the composer and for markdown blocks.

Does not work

@alice from a bot

Use instead

<@U012AB3CD>
Typing @alice in the composer autocompletes to a real mention. An API message must already carry the member ID — plain text never becomes a ping.

Does not work

markdown_text alongside blocks or text

Use instead

markdown_text on its own
Slack's docs are explicit: markdown_text must not be combined with blocks or text in the same chat.postMessage call. Pick one.

Does not work

```python in a mrkdwn field, expecting colors

Use instead

```python inside a markdown block
mrkdwn has no syntax highlighting, and the language name can show up as a literal first line. Highlighted code blocks are a markdown-block feature added in March 2026.

Does not work

Rebuilding a table as aligned text because "Slack has no tables"

Use instead

A markdown block, or a Block Kit table block
That was true until 2025. Markdown blocks render pipe tables, the table block gives an app structured rows with column alignment, and the data table block adds sorting and pagination.

Slack Formatting Quick Reference

Every syntax on one screen, with the surface it belongs to.

Complete Slack formatting syntax reference
FormatSyntaxNotes
Bold*text* (composer, mrkdwn) · **text** (markdown block)The most common source of confusion on Slack.
Italic_text_ (all three) · *text* (markdown block only)Underscores mean italic on every surface.
Strikethrough~text~ (composer, mrkdwn) · ~~text~~ (markdown block)One tilde everywhere except the markdown block.
UnderlineNo syntax — ⌘U in the composerA toolbar style only; nothing to type.
Link<url|text> (mrkdwn) · [text](url) (composer, markdown block)Both render identically once sent.
Autolink<https://example.com>Bare URLs also link themselves.
User mention<@U012AB3CD>Member ID, not display name.
Channel mention<#C123ABC456>Channel ID.
User group<!subteam^S0NHM1FH4>Group ID after a caret.
Broadcast<!here> · <!channel> · <!everyone>@everyone only works in #general.
Local timestamp<!date^unix^{date_short}|fallback>Rendered in each reader's timezone.
Inline code`code`Identical on every surface; suppresses other formatting inside.
Code block```code```Highlighting only inside a markdown block.
Blockquote> quoteStart each quoted line with >.
Bulleted list- itemComposer and markdown block only — not mrkdwn.
Ordered list1. itemComposer and markdown block only — not mrkdwn.
Heading# HeadingMarkdown block only; Slack's reference says all levels render the same size.
Table| a | b |Markdown block, or the Block Kit table and data table blocks.
Task list- [ ] taskMarkdown block only.
Divider---Markdown block, or the Block Kit divider block.
Image![alt](url)Becomes hyperlink text — use an image block or upload the file.
Emoji:tada:Slack stores emoji in this colon format, even when you send the Unicode character.
Escape&amp; &lt; &gt;Required in mrkdwn sent through the API.
Check before you ship: paste a message payload into Slack's Block Kit Builder to see it rendered before a bot sends it anywhere.

Frequently Asked Questions

Does Slack support Markdown?

Partly, and it depends on where you are typing. Slack's own format is mrkdwn, which looks like Markdown but is not: a single asterisk means bold, underscores mean italic, a single tilde strikes through, and links use <url|text>. The message composer uses the same single-character markup, plus [text](url) links. Real standard Markdown only works in a Block Kit markdown block (or the markdown_text argument), which Slack apps have been able to send since February 2025, and which handles headings, lists, tables and task lists.

How do I bold, italicize or strike through text in Slack?

Select the text and use the formatting toolbar, or press ⌘B / Ctrl+B for bold, ⌘I / Ctrl+I for italic and ⌘⇧X / Ctrl+Shift+X for strikethrough. To type it instead, wrap the text in one character on each side: *asterisks* for bold, _underscores_ for italic and ~tildes~ for strikethrough. Two asterisks is standard Markdown, not Slack markup.

Why does *text* show as bold in Slack but italic everywhere else?

Slack designed its markup separately from CommonMark and made different choices. In CommonMark a single asterisk means italic and a double asterisk means bold; Slack uses a single asterisk for bold and an underscore for italic. This is the single biggest reason text pasted from GitHub, Discord or a chatbot looks wrong in Slack.

Why is the formatting toolbar missing in Slack?

It has been hidden. Click the formatting icon in the message field to show it again. If it stays hidden, the "Format messages with markup" preference is probably on, which removes the toolbar on purpose: click your profile picture, choose Preferences, open Advanced, and uncheck it under Input options.

How do I send a real Markdown message to Slack from a bot?

Use a markdown block, or the markdown_text argument on chat.postMessage (chat.startStream takes it too, for streamed replies). Both take standard Markdown and let Slack do the conversion. markdown_text cannot be combined with blocks or text in the same call, the combined limit for markdown blocks in one payload is 12,000 characters, and markdown blocks work in messages only, not in modals or App Home.

Can Slack display a Markdown table?

Yes, since 2025, which reverses years of advice to the contrary. A pipe table inside a Block Kit markdown block renders as a real table. Apps can also build one with the table block (up to 100 rows, 20 cells per row, 10,000 characters), or since May 2026 the data table block, which adds sorting and pagination. Plain mrkdwn and the message composer still have no tables, so a table typed by hand into Slack remains a code block with spaces for alignment.

What is the difference between the composer, mrkdwn and a markdown block?

They are three different formatting surfaces. The composer is the box you type in: a formatting toolbar by default, plus Slack's single-character markup (*bold*, _italic_, ~strike~) and [text](url) links. Mrkdwn is Slack's stored message format, used by the API's text field and by mrkdwn text objects in Block Kit; it shares the composer's emphasis characters but links with <url|text>. The markdown block is a newer Block Kit block that accepts standard Markdown and converts it for you, so inside it **bold** is bold and *text* is italic.

Does Slack support Markdown headings?

Only inside a markdown block. Plain mrkdwn has no heading syntax and leaves the # characters literal, and the message composer's toolbar has no heading option. Slack's markdown-block reference says every heading level renders at the same size, although its March 2026 changelog lists variable-sized headers among the additions, so preview before relying on a hierarchy. Apps that want one distinct title should use a Block Kit header block.

Why don't my bullet lists work in Slack messages from the API?

Lists are not part of mrkdwn. Typing * and a space in the composer creates a rich-text list, and a markdown block renders - item and 1. item correctly, but a plain mrkdwn text field leaves the hyphens as characters. From an app, send the list in a markdown block or build it with a rich_text block containing rich_text_list elements.

How do I link to a URL with custom text in Slack?

In mrkdwn, use <https://example.com|Click here>: angle brackets around the URL and a pipe before the display text. In the composer and in markdown blocks the standard [Click here](https://example.com) form works instead, and the composer also has ⌘⇧U for turning selected text into a link.

Can I get syntax highlighting in a Slack code block?

In a markdown block, yes: language-specific highlighted code blocks arrived in March 2026, so ```python is honoured. Everywhere else, no. Plain mrkdwn and the composer render code blocks in a monospace font with no colouring, and because mrkdwn treats everything after the opening backticks as code, a language name can end up displayed as the first line.

How do I type Markdown in Slack instead of using the toolbar?

Turn on the markup preference: click your profile picture, choose Preferences, open Advanced, and check "Format messages with markup" under Input options. Your typing then stays plain until the message is sent, at which point Slack applies the formatting. The syntax is Slack's own: *bold*, _italic_, ~strikethrough~, `code`, > quote, ``` code blocks and [text](url) links. The preference also turns off automatic list formatting and makes pasted text arrive plain.

Does Slack have underline formatting?

In the composer only, and only through the toolbar or ⌘U on Mac. There is no underline markup to type, and no mrkdwn or markdown-block equivalent. Standard Markdown has the same gap, which is why underlining is usually faked with bold or italic instead.

How do I mention a user from a Slack bot or webhook?

Use <@U012AB3CD> with the member's Slack ID, which you can look up with the users.list method or copy from their profile. Channels use <#C123ABC456> and user groups use <!subteam^S0NHM1FH4>. Writing the display name as plain text never produces a notification, and a mention from an app only notifies people who are already in the channel.

How do I escape special characters in Slack API messages?

Replace the three characters Slack parses as control characters with HTML entities: &amp; for &, &lt; for < and &gt; for >. Encode only those three, not the whole string. This applies to mrkdwn sent through the API; the composer escapes for you. Inside a markdown block, use a backslash instead, as in \*not italic\*.

How do I disable formatting in Slack?

In the composer, press ⌘Z / Ctrl+Z straight after Slack applies formatting to undo it, or wrap the text in backticks, since nothing inside inline code is formatted. From an app there are three levers: set mrkdwn to false on a top-level message text, use a plain_text text object instead of a mrkdwn one inside a block, or set verbatim to true on a mrkdwn text object, which keeps the formatting but stops Slack auto-linking channel names and user handles.