WebToolsPlanet
Developer Tools

Markdown Table Generator, Formatter & Validator

Create, format, and validate GFM Markdown tables visually — Smart Paste auto-detects CSV, spreadsheet, or existing Markdown, flags broken tables, and lets you copy or download clean output.

Last updated: July 1, 2026

Client-Side Processing
Input Data Stays on Device
Instant Local Execution

Find this tool useful? Support the project to keep it free!

Buy me a coffee

What is Markdown Table Generator?

A Markdown table generator, formatter, and validator lets you build, clean up, and fix GFM (GitHub Flavored Markdown) tables without typing pipe characters by hand. GFM tables have three parts: a header row, a separator row that sets column alignment, and data rows. Writing this syntax manually is slow and error-prone — especially with many columns, data copied from a spreadsheet, or an existing table that's rendering wrong.

This tool gives you a visual spreadsheet-style editor plus a Smart Paste box that auto-detects what you paste — CSV, tab-separated spreadsheet cells, an existing Markdown table, or rough pipe-separated text — and imports it with diagnostics for anything that looks broken (missing separator row, uneven columns, invalid alignment markers).

You can add rows and columns, cycle column alignment between left, centre, and right, sort rows by any column, find and replace across cells, and start from a template (README feature table, API reference, changelog, pricing table, and more). Choose pretty aligned or compact Markdown output, and turn on pipe escaping so literal | characters inside cells don't break the table. A warnings panel flags empty headers, unescaped pipes, and other issues in your current table before you copy it. The preview renders your actual generated Markdown through a real GFM renderer, so what you see is what GitHub, GitLab, Notion, Obsidian, VS Code, Jira, and Docusaurus will show.

How to Use Markdown Table Generator

1

Paste CSV, spreadsheet cells, or an existing Markdown table into the Smart Paste box — it detects the format and shows you any issues before importing

2

Or click any cell in the starter table to edit it directly — press Tab to move to the next cell, Shift+Tab to go back

3

Use the "+" buttons to add columns/rows, click the alignment icon to cycle left/center/right, or load a ready-made template

4

Switch between Pretty and Compact output, and enable "Escape literal pipes" if any cell contains a | character

5

Check the warnings panel for issues, review the GitHub-style preview, then copy the generated Markdown or download it as a .md file

Common Use Cases

  • Adding a dependency comparison table to a GitHub README without manually formatting pipe characters
  • Creating a feature comparison matrix in developer documentation (Notion, Confluence, GitBook)
  • Generating a changelog table for a project's CHANGELOG.md with columns: Version, Date, Changes
  • Building a quick reference table for API endpoints in a REST API documentation file
  • Converting a Google Sheets project status table to Markdown for pasting into a GitHub issue
  • Creating a benchmark results table for a technical blog post or performance comparison writeup
  • Building a structured data table in a Jira wiki page for sprint planning or requirements documentation
  • Generating an accessibility quick reference table for a design system documentation page

Example Input and Output

Generating a formatted API endpoint reference table from a 3×4 grid:

Table editor data (3 cols, 4 rows)
Column 1: Method | Column 2: Endpoint | Column 3: Description
Alignment: center  | left               | left

Row 1: GET    | /users         | List all users
Row 2: POST   | /users         | Create a user
Row 3: PUT    | /users/{id}    | Update a user
Row 4: DELETE | /users/{id}    | Delete a user
Generated GFM Markdown
| Method | Endpoint | Description |
| :----: | :------- | :---------- |
| GET | /users | List all users |
| POST | /users | Create a user |
| PUT | /users/{id} | Update a user |
| DELETE | /users/{id} | Delete a user |

How This Tool Works

Table data is maintained as a headers/alignments/rows structure. Smart Paste runs a deterministic detector over pasted text — checking for a Markdown separator row, then tabs, then commas, then rough pipe separators — and routes it to the matching parser (Markdown, TSV, CSV, or pipe-text), returning both the parsed table and a diagnostics list. The Markdown output is generated by serializing that structure: cells are optionally escaped for literal pipes, then joined with " | " in either pretty (equal-width padded) or compact mode. The separator row encodes :--- (left), :---: (center), or ---: (right) per column. A separate validator checks the current editor state (empty headers, unescaped pipes, newlines, empty rows/columns, oversized tables) independent of raw import diagnostics. The preview renders the generated Markdown through the same remark/rehype GFM pipeline used by the Markdown to HTML tool, so it reflects real renderer behavior rather than a hand-built table. CSV import uses a RFC 4180-compliant parser to handle quoted cells with commas.

Technical Stack

Headers/alignments/rows table modelSmart Paste format detection (Markdown, TSV, CSV, pipe-text)RFC 4180 CSV parserIdempotent pipe escapingRaw import diagnostics + table state validatorGFM preview via remark/rehype (shared with Markdown to HTML)Client-side only

Client-Side Processing

All table editing and Markdown generation runs in your browser. Data you enter into the table editor is never sent to our servers.

Pretty vs. Compact Output

Pretty mode (the default) pads every cell in a column to equal width, matching what Prettier's Markdown formatter (prettier --parser markdown) would produce — so the raw source is easy to scan and diffs stay clean. Compact mode drops the padding for a smaller file. Toggle between them above the generated Markdown output; both render identically once parsed by a GFM renderer.

GitHub Table Scroll on Mobile

Wide tables on GitHub (many columns) render without horizontal scroll on mobile, causing overflow. Workaround: wrap your Markdown table in an HTML div with overflow-x:auto — GitHub's Markdown renderer passes through this HTML: <div style="overflow-x:auto">| col | col | ... |</div>. This works in GitHub but not all Markdown renderers accept raw HTML.

Frequently Asked Questions

What Markdown flavors support table syntax?
Tables are a GitHub Flavored Markdown (GFM) extension — they are not part of the original John Gruber Markdown specification or CommonMark. GFM tables are supported by: GitHub (README, issues, pull requests, wikis), GitLab (all Markdown contexts), Bitbucket (README files), VS Code (preview panel), Notion, Obsidian, Jira (wiki markup), GitBook, Docusaurus (MDX), and most static site generators (Gatsby, Hugo, Jekyll). Standard CommonMark renderers that don't include GFM extensions will render the pipe characters as plain text instead of a table.
How does column alignment work in GFM tables?
Column alignment is set by the separator row between the header and first data row. Left-aligned: --- or :--- (default). Center-aligned: :---:. Right-aligned: ---:. Example: | Left | Center | Right | / | :--- | :----: | ----: |. Alignment only applies to how Markdown renderers display the column — it does not affect text width or pad cells to fixed widths. GitHub renders left-aligned by default if no colon is specified.
Can I paste spreadsheet data directly?
Yes. Copy cells from Excel, Google Sheets, or Numbers and paste into the first cell of the editor. Tab-separated clipboard data (the default format when copying from spreadsheets) is automatically detected and expanded into the appropriate rows and columns. Comma-separated (CSV) data can also be pasted, but some spreadsheet cells may contain commas themselves — for that case, use the "Import CSV" button with a properly quoted CSV file instead.
How do I include pipe characters inside a table cell?
The pipe character (|) is the GFM table cell separator, so it must be escaped inside cell content: write \| to represent a literal pipe. Example: | a \| b | c | renders as a cell containing "a | b". Alternatively, use the HTML entity &vert; or &VeryThinSpace; which some renderers accept. Newlines inside cells are not supported in GFM — each row must be on a single line.
Is there a row or column limit?
GFM has no formal limit on table size. Practically: very wide tables (20+ columns) may overflow horizontally in Markdown renderers without scroll support (GitHub wraps wide tables; Notion scrolls them). Very tall tables are fine syntactically. For readability, tables over 10 columns should be broken into multiple focused tables. GitHub's Markdown renderer wraps text within cells, so narrow columns with long content create tall cells.
How can I convert an existing HTML table to Markdown?
To convert an HTML <table> to GFM Markdown: online tools like html2markdown.com perform this conversion. In Pandoc (CLI): pandoc input.html -f html -t gfm -o output.md. From a website table: right-click a table in Chrome → "Copy" → paste into html-to-markdown converter. The reverse (Markdown → HTML) is handled by the Markdown to HTML tool on this site. Note: complex HTML tables with rowspan, colspan, or nested elements cannot be represented in GFM Markdown syntax.
Why is my Markdown table not rendering on GitHub?
The most common causes: (1) a missing blank line before the table — GFM requires a blank line separating the table from preceding text; (2) a missing or malformed separator row between the header and data rows — it must use only -, :, and | characters; (3) an unescaped pipe character inside a cell, which GitHub reads as an extra column boundary; (4) a real newline inside a cell — GFM tables must be single-line per row, use <br> instead. Paste the table into this tool's Smart Paste box to get specific diagnostics for each of these.
How do I switch between compact and pretty Markdown table output?
Use the Pretty/Compact toggle above the generated Markdown output. Pretty mode pads every cell in a column to the same width, which is easier to read and edit as raw source but produces a longer file. Compact mode uses minimal single-space padding, which is smaller but harder to scan by eye. Both produce identical rendered output — the choice only affects the raw Markdown source formatting.
Can I import an existing Markdown table to edit it?
Yes. Paste an existing GFM Markdown table into the Smart Paste box — it's auto-detected as Markdown, alignment markers and escaped pipes are preserved, and it loads into the visual editor. If the pasted table is missing its separator row, has uneven columns, or uses an invalid alignment marker, the tool shows that as an import diagnostic before you import it.