TL;DR: Yes, you can render real tables in Slack. Slack's classic mrkdwn text format still ignores markdown table syntax, but Block Kit now includes a native table block (added in August 2025) that renders rows and columns in messages your app posts. If your content is already standard markdown, such as LLM output, the markdown block also renders pipe-syntax tables.
In this post, you'll learn about the Block Kit table block, how the markdown block works, limitations you should know, and the older workarounds (section fields, ASCII tables in code blocks, and images) that still make sense in a few cases.
How do you send a table in a Slack message?
To send a table in a Slack message, add a block with "type": "table" to the blocks array of a chat.postMessage request. The table block is part of Block Kit, Slack's framework for building message layouts from JSON components, so you send it the same way you send a header, section, or divider block.
A table block has two main parts: a rows array that holds your data, and an optional column_settings array that controls how each column displays. Each item in rows is one row, and each row is an array of cells. The first row works as your header row, so put your column labels there.
Here's a complete example using the official Node.js SDK, @slack/web-api. It maps an array of objects to rows of raw_text cells, adds a header block above the table, and posts the message to a channel. It also sets a top-level text value, which Slack uses for notifications:
import { WebClient } from "@slack/web-api";
const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
const data = [
{ month: "January", savings: "$250" },
{ month: "February", savings: "$80" },
{ month: "March", savings: "$420" },
];
const cell = (text) => ({ type: "raw_text", text: String(text) });
const rows = [
[cell("Month"), cell("Savings")],
...data.map((row) => [cell(row.month), cell(row.savings)]),
];
await slack.chat.postMessage({
channel: "C0123456789",
// Used for notifications and as a fallback where blocks can't render
text: "Our savings: January $250, February $80, March $420",
blocks: [
{
type: "header",
text: { type: "plain_text", text: "💰 Our savings" },
},
{
type: "table",
column_settings: [{ is_wrapped: true }, { align: "right" }],
rows,
},
],
});If you're posting the payload yourself or testing it in Block Kit Builder, the table block JSON looks like this:
{
"blocks": [
{
"type": "table",
"column_settings": [{ "is_wrapped": true }, { "align": "right" }],
"rows": [
[
{ "type": "raw_text", "text": "Month" },
{ "type": "raw_text", "text": "Savings" }
],
[
{ "type": "raw_text", "text": "January" },
{ "type": "raw_text", "text": "$250" }
],
[
{ "type": "raw_text", "text": "February" },
{ "type": "raw_text", "text": "$80" }
],
[
{ "type": "raw_text", "text": "March" },
{ "type": "raw_text", "text": "$420" }
]
]
}
]
}Before you write any code, you can mock up how a Slack notification will look with Knock's free Slack preview generator.
What cell types does the table block support?
Every cell in a table block has a type that tells Slack how to render its contents. Choose the type based on the data in the cell:
raw_text. Plain text. Use this for most cells.raw_number. Numeric values.rich_text. Formatted text using the same structure as the rich text block, which supports bold text, emoji, mentions, and links.
Most tables only need raw_text cells. Use rich_text when a cell needs formatting, such as a link, mention, or bold section label. Here's a rich_text cell that renders a bold text link:
{
"type": "rich_text",
"elements": [
{
"type": "rich_text_section",
"elements": [
{
"type": "link",
"url": "https://knock.app",
"text": "View report",
"style": { "bold": true }
}
]
}
]
}How do you align or wrap table columns?
By default, Slack left-aligns every column and truncates text that doesn't fit. To change either behavior, add the optional column_settings array to your table block. Each item applies to the column at the same position and accepts two properties:
align. Set toleft(the default),center, orright. Right alignment works well for numbers and currency.is_wrapped. Set tofalse(the default) ortrueto wrap long text instead of truncating it.
If column_settings has fewer items than your table has columns, the remaining columns use the default behavior. Slack's reference says you can pass null to skip a column, but developers have reported invalid_blocks errors when column_settings contains null. Passing an explicit object such as { "align": "left" } for skipped columns avoids the issue.
What are the limits of the Slack table block?
The table block handles most notification use cases, but Slack caps how much data a single table and message can hold. Plan for these limits upfront if your table displays variable-length data, such as query results or user-generated content. These limits come from Slack's table block reference and Block Kit docs:
- Rows. Up to 100 rows per table.
- Columns. Up to 20 cells per row, and up to 20 items in
column_settings. - Characters. A single table can't exceed 10,000 characters across all of its cells, and the same 10,000 character cap applies to all table cells in a message. Break large tables into separate messages.
- One table per message. Slack's own Block Kit patterns note that a message can contain only one table block. Send a second message if you need a second table.
- Blocks per message. The table counts toward the 50 block limit for a message.
- Fallback text. Always include a top-level
textvalue. Slack uses it for notifications, and mobile notifications show only this text.
Can you use markdown table syntax in Slack?
Yes, but only in a markdown block. Slack's default mrkdwn text format doesn't support tables, so the same markdown table renders as a formatted table in one block type and as raw text in another.
Here's a traditional markdown table:
| Month | Savings |
| -------- | ------- |
| January | $250 |
| February | $80 |
| March | $420 |If you send that string in a mrkdwn text object (for example, a section block or the top-level text field), Slack displays the pipes and dashes as literal characters. mrkdwn is Slack's own formatting syntax, and it doesn't include tables. Read the developer's guide to Slack's markdown formatting for a full breakdown of what mrkdwn does support.
If you send the same string in a markdown block, Slack renders it as a formatted table:
{
"blocks": [
{
"type": "markdown",
"text": "| Month | Savings |\n| --- | --- |\n| January | $250 |\n| February | $80 |\n| March | $420 |"
}
]
}Slack introduced the markdown block in February 2025 for apps that post AI-generated responses. It accepts standard markdown (including **bold**, [links](url), headers, code blocks, and tables) and translates it into Slack formatting for you. A few things to keep in mind:
- The cumulative limit for all
markdownblocks in a single payload is 12,000 characters. - Slack may translate one
markdownblock into several blocks, so you have less control over the final layout. - Slack ignores
block_idonmarkdownblocks.
Use the markdown block when you already have markdown, such as LLM output or content from a CMS. Use the table block when you build the table from structured data in your code, since it gives you control over alignment, wrapping, and cell formatting.
Which Slack table method should you use?
You have five ways to display tabular data in Slack, and each fits a different kind of content. The right choice depends on where your data comes from, how large it is, and whether readers need to search or copy it. This comparison covers what each method is best for and what you give up:
| Method | Best for | Trade-offs |
|---|---|---|
| Table block | Structured data from your app, up to 20 columns | One table per message, 100 rows, 10,000 characters |
| Markdown block | Content that's already in standard markdown, such as LLM output | Less layout control, 12,000 character limit |
| Section fields | Short label and value pairs | Two columns, 10 fields per section |
| ASCII table in a code block | Monospaced output, such as CLI or log summaries | Wraps poorly on mobile and narrow windows |
| Image upload | Large or styled tables, such as charts and reports | Not searchable or accessible as text, more API calls |
For most new apps, start with the table block. The sections that follow cover the older workarounds, which predate the table block but still fit a few use cases.
How do you build a table layout with section fields?
To build a table layout with section fields, use one section block per row, put each cell in the section's fields array, and separate the rows with divider blocks. A header block on top works as the table title. Before the table block existed, this was the common way to approximate a table in Slack:

This isn't a true table, but it gets close, and it uses Slack-native formatting. It's still a good fit for short label and value pairs, like the details of an alert or an approval request.
The resulting Block Kit JSON looks like this:
{
"blocks": [
{
"type": "header",
"text": {
"type": "plain_text",
"text": "💰 Our savings",
"emoji": true
}
},
{
"type": "section",
"fields": [
{ "type": "mrkdwn", "text": "*Month*" },
{ "type": "mrkdwn", "text": "*Savings*" }
]
},
{ "type": "divider" },
{
"type": "section",
"fields": [
{ "type": "mrkdwn", "text": "January" },
{ "type": "mrkdwn", "text": "$250" }
]
},
{ "type": "divider" },
{
"type": "section",
"fields": [
{ "type": "mrkdwn", "text": "February" },
{ "type": "mrkdwn", "text": "$80" }
]
},
{ "type": "divider" },
{
"type": "section",
"fields": [
{ "type": "mrkdwn", "text": "March" },
{ "type": "mrkdwn", "text": "$420" }
]
},
{ "type": "divider" }
]
}To learn more about how sections, fields, and dividers fit together, read our deep dive into Slack's Block Kit.
Limitations of section fields for tables
Section block fields render in a compact, two column layout, so you can't display more than two columns. Each section accepts up to 10 fields, and each field's text can be up to 2,000 characters. Every row also uses two blocks (a section and a divider), so you reach the 50 block per message limit after about 24 rows. If you need more columns or rows, use the table block.
How do you render an ASCII table in a Slack code block?
An ASCII table uses plain text characters, such as pipes, dashes, and plus signs, to draw rows and columns. Slack displays code blocks in a monospaced font and preserves their spacing, so the columns stay aligned. This approach borders on hacky, but it produces a readable result for monospaced data, like CLI output or log summaries.
To render one, use a function in your application to turn your data into an ASCII text table, then wrap that text in a multiline code block.
The example below is written in JavaScript. It takes an array of objects and uses the keys as headers for the table columns:
function createAsciiTable(data) {
if (!data || data.length === 0) {
return "No data provided";
}
// Extract headers from the first object's keys
const headers = Object.keys(data[0]);
// Calculate the maximum width for each column
const columnWidths = headers.map((header) =>
Math.max(
...data.map((row) => row[header].toString().length),
header.length,
),
);
// Create the divider
const divider =
"+" +
headers.map((header, i) => "-".repeat(columnWidths[i] + 2)).join("+") +
"+";
// Create the header row
const headerRow =
"|" +
headers
.map((header, i) => ` ${header.padEnd(columnWidths[i])} `)
.join("|") +
"|";
// Generate each row of data
const rows = data.map(
(row) =>
"|" +
headers
.map(
(header, i) => ` ${row[header].toString().padEnd(columnWidths[i])} `,
)
.join("|") +
"|",
);
// Assemble the full table
return [divider, headerRow, divider, ...rows, divider].join("\n");
}
// Example usage
const data = [
{ Month: "January", Savings: "$250" },
{ Month: "February", Savings: "$80" },
{ Month: "March", Savings: "$420" },
];
console.log(createAsciiTable(data));If you run this function with the data provided, you get this output:
+----------+---------+
| Month | Savings |
+----------+---------+
| January | $250 |
| February | $80 |
| March | $420 |
+----------+---------+From there, wrap that text in a multiline code block and send it with chat.postMessage. The result looks like this in Slack:

Here's how it all fits together in a Next.js server action, using the createAsciiTable function and data array from the previous example:
"use server";
import { WebClient } from "@slack/web-api";
const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
export async function sendTableMessage(channel) {
const tableString = createAsciiTable(data);
const codeBlock = "```$table```".replace("$table", tableString);
return slack.chat.postMessage({
channel,
text: "Our savings: January $250, February $80, March $420",
blocks: [
{
type: "header",
text: { type: "plain_text", text: "💰 Our savings", emoji: true },
},
{
type: "section",
text: { type: "mrkdwn", text: codeBlock },
},
],
});
}Since createAsciiTable adds a newline character to the end of each row, you only need to store its output in tableString and wrap it in triple backticks: "```$table```"
Since the codeBlock string contains backticks, this example uses
String.replace instead of a template literal.
Limitations of ASCII tables in Slack
The biggest drawback of ASCII tables is readability. The alignment depends on each line fitting the width of the window. As you resize the Slack app, view the message on mobile, or open it in a thread, long lines can wrap and break the columns apart.
The code block also counts toward the text limit of the block that contains it. A section block's text can be up to 3,000 characters, and each item in fields can be up to 2,000 characters. Put the code block in text rather than fields to get the most room.
For anything beyond monospaced output, the table block is now the better choice.
Can you send a table to Slack as an image?
Yes. You can render the table as an image in your app (for example, with a charting or headless browser library) and upload it to a channel. This works for large or styled tables, but the data isn't searchable or readable by screen readers as text.
If you've uploaded files to Slack before, note that the process has changed. Slack retired the old files.upload method on November 12, 2025. To upload files now, use the three-step upload flow:
- Get an upload URL. Call
files.getUploadURLExternalwith the file name and length in bytes. Slack returns anupload_urland afile_id. - Upload the file. Send the file contents to the
upload_url. - Complete the upload. Call
files.completeUploadExternalwith thefile_idand achannel_idto share the file in a channel.
Video walkthrough
If you prefer to learn with video, this walkthrough covers the section fields and ASCII table approaches. We recorded it before Slack released the table block.
Frequently asked questions
Does Slack support markdown tables?
Not in mrkdwn, Slack's default text format. If you send markdown table syntax in a mrkdwn text object, Slack shows the pipes and dashes as plain characters. Slack does render markdown tables inside a markdown block, and the Block Kit table block renders native tables from structured JSON.
What is the Slack table block?
The table block is a Block Kit block with "type": "table" that displays rows and columns in a message. Slack released it in August 2025. Each row is an array of cells, and cells can be raw_text, raw_number, or rich_text. You send it in the blocks array of a chat.postMessage request.
How many rows and columns can a Slack table have?
A Slack table block can have up to 100 rows and 20 cells per row. All of the cells in a table, and all table cells in a message, can't exceed 10,000 characters combined. Split larger data sets across multiple messages.
Can I put more than one table in a Slack message?
No. A Slack message can include one table block. To show a second table, send it in a separate message or in a thread reply.
Can I add links or bold text inside a Slack table?
Yes. Use a rich_text cell instead of a raw_text cell. Rich text cells support bold and italic styles, links, emoji, and user mentions.
What is the difference between the markdown block and the table block?
The markdown block accepts standard markdown, including table syntax, and Slack converts it for display. The table block takes structured rows and cells and gives you control over column alignment and text wrapping. Use the markdown block for existing markdown such as LLM output, and the table block for data your app builds.
Knock helps you ship Slack notifications faster
If you're building a Slack app for your product, Knock created SlackKit to help developers simplify the process. SlackKit gives you drop-in components to handle Slack OAuth and channel selection. Knock stores those Slack connections and uses them in multi-channel notification workflows that reach your users where they work. Read getting started with SlackKit or the Knock Slack docs to learn more.
Here are more posts on building Slack notifications:
- The developer's guide to Slack's markdown formatting
- Taking a deep dive into Slack's Block Kit
- How to authenticate users in Slack using OAuth
- Using Slack ephemeral messages in product notifications
- Troubleshooting channel_not_found in Slack incoming webhooks
To add Slack notifications to your application, sign up for Knock or reach out to us in our Slack community.
