Who it is for · Updated 22 September 2026 · By Evgeny K.

Web tables to Markdown without breaking the rows

To bring web tables to Markdown, Clean Web Clipper serialises each table itself, rather than handing it to a generic HTML-to-Markdown converter, so a cell holding a list, a link or a code sample gets flattened instead of breaking the whole row. Generic converters typically drop exactly the tables that carry the numbers worth keeping.

Where these numbers come from: the benchmark, with engine versions and dates

Where do the numbers go missing?

The table is the reason you saved the page: pricing tiers, rate limits, retention periods, a schema. You paste the clip into your notes and find one row spread over a page, pipes in the wrong places, and a column that has silently merged with its neighbour. The numbers are still on screen behind you in the browser, so the failure is easy to miss, until the tab is gone.

The opposite failure costs the same afternoon. Plenty of sites still use a table purely for positioning, and a converter that treats every one of them as data hands you twenty rows of navigation dressed up as a dataset. One outcome is spent retyping numbers, the other deleting a grid, and neither is the analysis you sat down to do.

Retyping has a third cost that shows up much later. A number typed into a sheet by hand carries no source, no date and no way to check it – six weeks on, nobody can say whether the retention period in cell D14 was read off the page in January or in March, and the page has been edited twice since. Pricing, rate limits and quotas change without an announcement. A captured table with the source URL and the page’s declared date above it answers that question, and answers it again next quarter when you capture the same page and diff the two.

What comes across, and how often?

• A GFM table serialiser written for this, not a generic converter plugin bolted on.
• 12 tables of 15 kept on 9 technical pages in a separate pre-release check (August 2026), against 7 each for Defuddle and Mozilla Readability.
• Small ragged two-column tables – up to 12 rows – become **key**: value lines, key and value on one line, instead of a broken grid.
• Layout tables are unwrapped – grids used only for positioning give up their content without the grid.
• Code inside a cell stays code – inline and on one line, without a language tag, because a table cell cannot hold a fenced block.
• Select a table on the page and clip the selection, when the surrounding article is not needed.
• The source URL and the page’s declared date sit above the table, so a set of numbers carries the date it was valid on rather than the date you happened to file it.
• A second capture of the same page takes a numeric suffix instead of overwriting the existing file – which is what makes a quarterly diff possible at all.

…
### 3.1.1. Affinity Name Examples

The following table shows how many common datatype names from more traditional SQL implementations are converted into affinities by the five rules of the previous section. This table shows only a small subset of the datatype names that SQLite will accept. Note that numeric arguments in parentheses that following the type name (ex: "VARCHAR(255)") are ignored by SQLite - SQLite does not impose any length restrictions (other than the large global [SQLITE\_MAX\_LENGTH](https://sqlite.org/limits.html#max_length) limit) on the length of strings, BLOBs or numeric values.

> | Example Typenames From The CREATE TABLE Statement or CAST Expression | Resulting Affinity | Rule Used To Determine Affinity |
> | --- | --- | --- |
> | INT INTEGER TINYINT SMALLINT MEDIUMINT BIGINT UNSIGNED BIG INT INT2 INT8 | INTEGER | 1 |
> | CHARACTER(20) VARCHAR(255) VARYING CHARACTER(255) NCHAR(55) NATIVE CHARACTER(70) NVARCHAR(100) TEXT CLOB | TEXT | 2 |
> | BLOB no datatype specified | BLOB | 3 |
> | REAL DOUBLE DOUBLE PRECISION FLOAT | REAL | 4 |
> | NUMERIC DECIMAL(10,5) BOOLEAN DATE DATETIME | NUMERIC | 5 |
…

Set it up for tables

Two settings and one habit. The habit, scrolling before you clip, recovers more rows than any setting can.

1. Open Options from the extension icon and in Where to save set Folder on disk to the folder where the working data lives – data/sources beside the notebook or the sheet that consumes it.
2. Leave the icon click as the preview window. A table is the one thing worth looking at before it is filed – whether the columns line up is visible in one glance and invisible in a folder listing.
3. Set the filename template to {date}-{domain}-{title}, and save each quarter’s round into its own subfolder, named for the quarter. There is no separate variable for the clip day: {date} is the publication date whenever the page declares one, so every capture of a dated page gets the same date, and only the folder keeps them in capture order. A repeated name in the same folder gets a number added instead of replacing the existing file.
4. Under Properties, turn on source and published (the file’s date line). A table without the address it came from is a set of numbers somebody will eventually have to re-derive.
5. Before clipping, scroll to the bottom of the table. Rows that load as you scroll do not exist in the DOM until they have loaded, and the extension reads the DOM at the moment you clip.
6. When the surrounding article is irrelevant, select the table on the page and clip the selection. A strip at the top of the window confirms the selection was taken rather than the whole page.
7. Put a recurring capture in the calendar for the pages whose numbers move: quotas, prices, retention periods. The value of the corpus is in the second capture, not the first.

Which settings suit numbers you will reuse?

For numbers you will reuse, Clean Web Clipper is set up so that a table read six months from now still says where it came from and when.

---
title: "Comma-separated values - Wikipedia"
source: "https://en.wikipedia.org/wiki/Comma-separated_values"
date: "2004-03-03T14:56:47.000Z"
extraction: "dom"
---
Text format for tabular data using a comma between fields

Comma-separated values

**Filename extension**: .csv

**Internet media type**: text/csv[^1]

**Uniform Type Identifier (UTI)**: public.comma-separated-values-text[^2]

**UTI conformation**: public.delimited-values-text[^2]

**Type of format**: multi-platform, serial data streams

**Container for**: database information organized as field separated lists

**Standard**: RFC 4180
…

See three tables, three outcomes

Three tables below show three different outcomes: four pricing pages assembled into a comparison sheet without retyping a number, one provider’s limits compared a quarter apart to catch an unannounced change, and a ragged two-column grid that comes across as key-value lines instead of a broken table. Each depends on the serialiser reading the table itself, not a generic converter.

A pricing table into a comparison sheet

Four vendors, four pricing pages, four captures. Each table comes across as a GFM table with the plan names, the amounts and the limits in the cells they were in, and the source URL above it, so the comparison sheet is assembled without a single number being retyped.

This is where the serialiser earns its place – the cells that break generic converters are the ones with a footnote marker, a list of included features or a code sample inside. The measured figure does not come from pricing pages: in a separate pre-release check on 9 technical pages in August 2026, 12 of 15 tables survived against 7 each for Defuddle and Mozilla Readability, so check a pricing grid in the clip window.

The same page, a quarter apart

You captured a provider’s rate limits in February and again in May. The second file took a numeric suffix. A diff shows the burst allowance halved on the starter plan and the retention window on the top plan extended – neither of which was announced anywhere.

Without the February file the change is unprovable, because the page shows only its current state and the previous numbers exist nowhere the vendor publishes. The whole method depends on the first capture having been cheap enough to take before you knew it mattered.

A grid that could not be a table

A specification page defines eight headers in a two-column grid with uneven rows and a short list in one row. Reproduced as a Markdown table it would have collapsed; instead each row comes across as one line – the key in bold, a colon, then the value – which is lossless for reading and for searching.

That behaviour is deliberate rather than a fallback failure. Ragged two-column tables are far more often definition lists wearing a grid than they are data, and a broken pipe table is harder to repair than a list is to read.

How does it compare to the usual ways to move a table?

Every one of these gets numbers off a page. They differ in what arrives with the numbers and in what you have to do afterwards.

What happens when a table does not come out right?

Four outcomes cover almost every table that Clean Web Clipper does not bring out right: merged cells flattened because Markdown cannot express them, rows missing because the page had not finished loading them, a navigation grid mistakenly marked up as data, or a ragged table turned into key-value lines on purpose. Each comes with the reason it happens rather than just the symptom.

The merged cells are gone

Markdown has no merged cells, so colspan and rowspan are flattened – the text is preserved and the visual merge is not, because the format cannot express it. Where a merged header spanned three columns, the text lands in the first of them and the headers after it move left, so check which column each value sits in against the page.

Half the rows are missing

The extension reads the DOM at the instant you clip, so rows that a page loads as you scroll (or serves through a “show more” button, or paginates) do not exist yet unless you have caused them to. Scroll to the bottom, expand what expands, then clip. For a paginated table, clip each page – the parts can be joined afterwards, and nothing else can recover rows the browser never received.

I got a grid of navigation instead of data

A grid of navigation is a layout table: a grid used purely for positioning, which many older sites still use for menus and headers. Those are unwrapped rather than converted, so the content comes through without the grid. If a navigation grid did reach the note as a table, it is because the page marked it up as a data table – the markup said “data” and the extension believed it.

The table came out as key and value lines

Key and value lines come from the ragged two-column path. A two-column table with uneven rows is usually a definition list drawn as a grid, and reproducing it as a pipe table produces a broken grid rather than a readable one. The content is complete: bold key, then the value on the same line, in the original order. Only tables of up to 12 rows take this path; larger ones stay a grid. If you need it as a real table, the pairs convert back mechanically.

Where does the format give out?

Markdown has no merged cells, so colspan and rowspan are flattened – the text is preserved, but the cells after a merge can shift into the wrong column, and a table caption is not kept. A table nested inside a cell is hard for every tool. Clean Web Clipper does not read numbers out of a chart image, and it exports no CSV or XLSX. And it converts one page at a time – the page you are on.

The output is Markdown, and only Markdown.

What does a table keep, and what does it lose?

What happens to a table used purely for layout? A layout table is unwrapped. Reproducing a positioning grid as a Markdown table produces noise, so the content is kept and the grid is not.

Where does table extraction stop?

Does it read numbers out of a chart? No. A chart is an image or a canvas, and the extension does no image processing of any kind. Where a page publishes the underlying figures as a table below the chart – many statistical agencies do – that table clips normally.