Markdown Table Generator

What this tool does

Fill in the grid and the table appears in the output panel the moment you type — there is no button to press. Add or remove rows and columns, and set each column to left, center or right alignment from the menu above it. Pick the output you need from the format switch: the same grid serializes to GitHub-Flavored-Markdown, a semantic HTML <table>, RFC-4180 CSV or tab-separated text, a LaTeX tabular, a MediaWiki (Wikipedia) table, an AsciiDoc table, or Jira wiki markup. A table copied from a web page or Word pastes straight into the grid, and you can sort it by any column or transpose it before exporting. Below it a live HTML preview shows how the finished table actually renders, alignment and all. When it looks right, Copy the active format or Download it (.md, .html, .csv, .tsv, .tex, .wiki, .adoc or .txt for Jira). Download Excel (.xlsx), under the output, writes the same grid as a real spreadsheet instead.

Eight output formats from one grid

The grid is the single source of truth; each output is generated from it on the fly:

• Markdown — GitHub-Flavored-Markdown with the delimiter row and per-column alignment, columns padded so the raw source is readable and diffs cleanly. Pipes and backslashes are escaped (see above).
• HTML — a semantic <table> with <thead>/<tbody>, alignment applied via style="text-align:…". Every cell value is HTML-escaped — <, > and & become <, > and & — with the ampersand escaped first, so a cell containing a < b or a stray <script> is inert text, not markup.
• CSV — comma-separated using the RFC 4180 rules: a field that contains a comma, a double-quote or a line break is wrapped in quotes, and inner quotes are doubled (""), so She said "hi", loudly exports as one field and re-imports intact.
• TSV — tab-separated, which is exactly what Excel and Google Sheets read from the clipboard, so a copied cell block pastes straight into a spreadsheet.
• LaTeX — a plain tabular environment with \hline rules above and below the header and at the end, so it compiles with no extra packages. The column spec follows your alignment (l, c, r; Default becomes l). All ten characters LaTeX treats specially are escaped in one pass: & % $ # _ { } get a backslash, and ~, ^ and \ become \textasciitilde{}, \textasciicircum{} and \textbackslash{}. A cell reading R&D: 50% of $2_000 comes out as R\&D: 50\% of \$2\_000, which compiles; pasted raw, the & alone would end the column early.
• MediaWiki — {| class="wikitable" markup for Wikipedia or any MediaWiki site, with a style="text-align:…" attribute on aligned columns. A literal pipe becomes | so it cannot end the cell.
• AsciiDoc — a |=== block with the header row marked, alignment written into the cols attribute (< left, ^ centre, > right), pipes escaped as \|, and {name} escaped so it is not swallowed as an attribute reference.
• Jira — wiki markup with || header cells and | body cells, for Jira issues and comments that use the wiki-style text renderer. Empty cells get a space (otherwise || would read as a header separator), pipes and backslashes become | and \, and { is escaped so it cannot open a macro.

Excel (.xlsx) is a ninth export, a file rather than text: one sheet with the header row in bold and frozen, each column keeping its left, center or right alignment, and column widths sized to the longest entry (up to 60 characters, after which the cell wraps). A cell that is a plain decimal number such as 3.5, -12 or 1000 becomes a real number you can sum; anything else stays text exactly as typed, so 007 keeps its zeros, 1e5abc is not read as scientific notation, and 2026-10-15, 1,000 and 12% are not reinterpreted. A number with more than 15 significant digits (a card or order ID) also stays text, because Excel keeps only 15 and would change it. The file is assembled in your browser and saved directly; the table is not sent anywhere.

A link from Copy link remembers which of these formats you were on, so it can open somebody straight onto the LaTeX or Jira version of the table.

Pasting a table from a web page, Word or Google Docs

When you copy a table in a browser, Word, Google Docs or Google Sheets, the clipboard carries it as HTML. Paste anywhere on the page outside a text field, into the Paste to import box, or over a cell in the grid, and that HTML table fills the grid immediately; the note under the grid reports the rows and columns it read. Only the text of each cell is kept: links, bold and colours go, Wikipedia's [1] footnote markers and hidden sort keys are dropped, and a <br> inside a cell stays a line break. If what you copied holds more than one table, only the first is read.

Merged cells are the one thing that cannot survive as-is: Markdown, CSV, Jira and the rest have no colspan or rowspan. A merged cell is therefore split, and its text is copied into every slot it covered, so sorting and column counts stay correct. The import note says how many merged cells were split, for example “1 cell spanning columns had their text copied into every slot they covered”, so you can find them and blank the copies you do not want.

Sorting and transposing

Sort rows by… reorders the data rows by any column, ascending or descending; the header row stays on top. Values that read as numbers sort by value, not as text: 200 comes before 1,000, and thousands separators, a leading $, € or £, a trailing % and a minus sign are understood. Numbers come before text, text is compared alphabetically with digit runs read as numbers (so Item 9 sorts before Item 10), and empty cells always go to the bottom. Rows with equal values keep their original order. Decimal commas such as 3,50 are read as text, not as 3.5.

Transpose swaps rows and columns, so the old header row becomes the first column. Pressing it twice returns the original table exactly. Column alignment is reset to Default, because it belonged to columns that no longer exist.

Honest delimiter detection when you paste

On import the tool counts commas and tabs (ignoring anything inside quoted fields) and picks whichever is more frequent. When the two counts are equal and both actually appear, there is no correct guess — so instead of silently choosing, it imports as CSV and tells you it was ambiguous, so you can fix the source rather than discover a mangled table later. TSV normally wins whenever tabs outnumber commas, matching a spreadsheet paste.

The one bug this tool exists to prevent: escaping pipes

A Markdown table uses the pipe character | to separate columns, so a pipe inside a cell — a bitwise-OR in a code snippet, a "yes | no" note, a file path with | — will silently split that cell in two and wreck the whole row. The fix is to escape it as \|, and to escape a literal backslash as \\. The subtle part is the order: you must escape the backslash first, otherwise the backslash added by \| gets doubled and you end up with \\|. This tool always escapes backslash-then-pipe, so:

Reading a table back in reverses this exactly, so a\|b becomes the literal cell a|b again — a genuine round-trip, not a lossy one.

Worked example

A three-column grid with the header Name, Score, City, left / right / center aligned, and two data rows, generates exactly this — columns are padded so the raw Markdown is readable and diffs cleanly:

| Name  | Score |  City  |
| :---- | ----: | :----: |
| Ada   |    95 | London |
| Grace |    82 | Berlin |

Notice the delimiter row (line 2): :--- means left, ---: means right, and :--: means center. A bare --- with no colons means "renderer default", which most renderers show as left — this tool keeps that distinction so a Default column is not silently rewritten as an explicit Left when you re-import the table.

Pasting from Excel, Google Sheets, or an existing table

Open the Paste to import tab and paste. The importer auto-detects the format:

• TSV — copying cells out of Excel or Google Sheets puts tab-separated text on your clipboard, so a plain paste just works.
• CSV — comma-separated files are parsed with the RFC 4180 rules: a quoted field such as "Smith, John" stays one cell despite the comma, and a doubled "" inside a quoted field un-escapes to a single quote.
• Markdown — paste a table you already have and it is parsed back into editable cells, alignment included, so you can tweak a value and regenerate.

If an imported row has fewer cells than the widest row, it is padded with empty cells and the import note tells you how many rows were padded — Markdown tables must be rectangular, so this is done openly rather than by dropping data.

The opposite case is reported differently, because it is a different edit. If a row has more cells than the header, a column is added to the header so your extra value is kept. Be aware that this is not what a Markdown renderer does with your original source: the GitHub Flavored Markdown spec (section 4.10, Tables) says that if a row has more cells than the header row, the excess is ignored — so pasting | a | b | with a data row of | 1 | 2 | 3 | renders on GitHub as a two-column table with the 3 discarded. This tool keeps the 3 and says so in the import note, on the view that losing a cell you typed is worse than showing you one more column than your source produced. Delete the added column if you would rather match the renderer.

Sending the table to somebody else

Markdown pastes into a pull request or a wiki, but it does not travel well in a chat window, and a screenshot of a table is the one thing the person receiving it cannot edit. Copy link, below the editor, builds a URL that carries the whole grid — every cell's text and each column's alignment — in the part of the address after the #. Whoever opens it gets this editor with the table already loaded and the Markdown already generated, and can change a cell and send it back.

The part of a URL after the # is the fragment, and a browser strips it before the request goes out: it is never sent to this site, never written to a server log, and never reaches anything in between. That is what makes this a safe place to put a table you would not paste into a form. It also means the link is the data — anyone who can read the URL can read every cell — so send it the way you would send the table itself.

The editor never rewrites your address bar as you type. That is deliberate: a table can hold a customer list or a salary column, and pushing it into browser history and onto a shared screen without being asked is not a convenience. A link exists only when you press the button.

The cap is 4,000 characters once encoded, and different text costs different amounts: a plain ASCII character costs 1, a space or a pipe costs 3 (%20, %7C), an accented letter like é costs 6, a CJK character 9, an emoji 12. The three-column, three-row Worked example table above encodes to 52 characters (t1_lrc_Name~Score~City_Ada~95~London_Grace~82~Berlin); a 40-row × 4-column table of eight-letter entries encodes to 1,447, so a table of short cells fits with room to spare while a table of full sentences will not. Over the cap the button refuses and says so — nothing is ever trimmed to fit, because half a table is a different table.

Honest limits

New to the syntax itself? Markdown Tables Explained is a first-principles guide to the header and delimiter rows, the alignment colons, escaping a literal pipe, and exactly what the GFM spec does with rows that have too few or too many cells.

GitHub-Flavored-Markdown tables are deliberately simple, and this tool does not pretend otherwise. There are no merged/spanning cells (colspan/rowspan) — GFM has no syntax for them, which is why a pasted merged cell is split. In the MediaWiki and Jira outputs, markup inside a cell ([[link]], *bold*) is passed through and will be rendered as markup; LaTeX and AsciiDoc fold a line break inside a cell to a space. A cell cannot contain a real line break; if you paste multi-line content, the newline is folded to a <br> so the row stays valid. Basic inline Markdown inside a cell (like **bold** or a `code` span) is passed through as text and will render wherever your Markdown renderer supports it, but block content — lists, headings, code fences — cannot live inside a table cell. For anything richer than a rectangular grid, you need real HTML.

Common mistakes

• Unescaped pipes. The classic broken row. Let the tool escape them instead of typing | into raw Markdown by hand.
• Missing the delimiter row. A GFM table is invalid without the second --- line; the generator always emits it.
• Ragged columns. Rows with different cell counts render as a broken table — import padding fixes this, but check the padded blanks are what you meant. A row with more cells than the header is the trickier half: a column is added here to keep the value, while GFM renderers ignore the excess, so the imported grid deliberately has one more column than your pasted source rendered.
• Expecting alignment everywhere. Some Markdown renderers ignore column alignment entirely; the colons are still valid, they just may not visibly align.

Frequently asked questions

How do I put a pipe (|) character inside a Markdown table cell?

Just type it into the cell — this tool escapes it for you as a backslash-pipe (\|), which is the only way a literal pipe can live inside a GitHub-Flavored-Markdown cell without ending the column early. It also escapes a literal backslash as a double backslash (\\), and it does the backslash first so an escaped pipe never gains a stray extra backslash. That ordering is the single most common hand-authoring bug in Markdown tables, and it is why a cell like 'a|b' comes out as 'a\|b' here.

Can I paste a table from Excel or Google Sheets?

Yes. Switch to the 'Paste to import' tab and paste. Copying cells out of Excel or Google Sheets puts tab-separated values on your clipboard, and the importer auto-detects tabs versus commas, so a straight paste becomes a grid you can keep editing. Comma-separated (CSV) files are parsed with the RFC 4180 rules, so a quoted field like "Smith, John" stays a single cell even though it contains a comma, and a doubled double-quote ("") un-escapes to one.

Can it read an existing Markdown table back into the grid?

Yes — paste a Markdown table into the import box and it is parsed back into editable cells, including the per-column alignment read from the ':---' / ':--:' / '---:' delimiter row. Escaped pipes (\|) and backslashes (\\) are un-escaped back to their literal characters. This makes the tool a round-trip editor: generate a table, paste it somewhere, and later paste it back to tweak a value or add a row without rebuilding it by hand.

What happens to a row that has fewer or more cells than the header?

Ragged rows are reconciled honestly, and the two directions are reported separately because they are different edits. When an imported row has fewer columns than the widest row, the missing cells are filled with empty strings so the table stays rectangular, and the import note tells you exactly how many rows were padded. When a row instead has more cells than the header, a column is added to the header so your extra value is kept, and the import note says that too. That second case is worth knowing about: the GitHub Flavored Markdown spec (section 4.10, Tables) says a row with more cells than the header row has its excess ignored by the renderer, so your pasted source would show fewer columns on GitHub than the grid you see here. This tool keeps the cell rather than dropping data you typed, and tells you the two differ — you can then fill the blanks or delete the added column.

How does per-column alignment work, and does the default matter?

Each column has an alignment control: Default, Left, Center or Right. These map to the delimiter row markers — ':---' is left, ':--:' is center, '---:' is right, and a bare '---' is the renderer's default (usually left). The distinction is preserved on round-trip: a Default column stays a bare '---' when you re-import it, rather than being rewritten as an explicit left, so your table survives editing unchanged. The live preview on the right shows how each alignment actually renders.

Can I send somebody a link that opens the finished table?

Yes. Press the Copy link to this table button below the editor: it builds a URL that carries every cell's text and each column's alignment in the part of the address after the # character. Opening that link loads the table into the grid and generates the Markdown at first paint, with nothing to click. A fragment — everything after the # — is stripped by the browser before the request goes out, so it never reaches this site or any log on the way; but it is in the URL, so anyone who can read the link can read every cell. Your address bar is never rewritten while you type: a link exists only when you press the button. The cap is 4,000 characters once encoded, and past it the button refuses and says so rather than trimming the table.

How do I paste a table from a web page, Word or Google Docs?

Copy the table in the browser or in Word, Google Docs or Google Sheets, then paste anywhere on this page outside a text field (or into the Paste to import box). Those programs put the table on the clipboard as HTML, and the tool reads that HTML table straight into the grid: the first row becomes the header, links and bold are reduced to their text, Wikipedia footnote markers like [1] and hidden sort keys are dropped, and a line break inside a cell is kept. Markdown, CSV and the other formats have no merged cells, so a cell that spans two columns or rows is split and its text copied into every slot it covered; the import note says how many were split so you can blank the copies you do not want. Only the first table in what you copied is read.

Is my data uploaded anywhere?

No. The grid editor, the Markdown generator and both parsers are plain JavaScript that runs inside this page. There are no network requests for your content — you can disconnect from the internet and it keeps working — so a table you paste in, however sensitive, never leaves the tab and is gone when you close it.