How to Convert a URL List into JSON, Markdown, CSV, SQL IN, and TypeScript

A flat list of URLs is the rawest format there is. One link per line, no quotes, no commas, no brackets. It comes out of a sitemap, a redirect spreadsheet, a crawl log, a Slack paste, or a column someone copied out of a CRM. It is easy to read, but the moment you need to use it in code or a document, you are stuck wrapping every line by hand: adding quotes for a JSON array, square brackets for a SQL clause, link syntax for a Markdown doc.

The URL List Converter takes that plain list and re-emits it in the format your next step actually expects. Paste the lines, pick an output, and the same set of links comes back as a JSON array, a Markdown link list, CSV, a SQL IN clause, a TypeScript union, or back to plain lines. Everything runs in the browser, so a column of internal URLs never leaves the tab.

The output formats this tool offers

Per the tool itself, you can switch the same parsed list between six outputs:

• Plain lines — one URL per line, normalized and optionally deduplicated.
• CSV — rows with the value, the normalized form, source line number, and a validity reason, so the output stays aligned row-for-row with what you pasted.
• JSON — a JSON array of the URLs, ready to drop into a config file, a fixture, or an API payload.
• Markdown — a link list, so a flat column becomes a bulleted set of clickable links in a doc.
• SQL IN — a parenthesized, comma-quoted list you can paste straight after WHERE url IN.
• TypeScript union — a string union type, useful for a typed allowlist or route map.

That is the whole point: a flat URL list becomes a Markdown bullet list of links, a JSON array, or a SQL IN clause in one step instead of you hand-wrapping each line. That is handy for a redirect-map doc, for seeding a crawl queue, or for turning a sitemap into a typed constant. You are not asked to learn an export wizard. You paste, you flip a toggle, you copy or download.

A worked example: plain list to JSON and Markdown

Here is a small, real list of URLs you might pull off a sitemap or a redirect spreadsheet:

https://example.com/blog/launch
https://example.com/pricing
https://example.com/docs/api

Pick JSON and the converter returns a clean array:

[
  "https://example.com/blog/launch",
  "https://example.com/pricing",
  "https://example.com/docs/api"
]

Flip the output to Markdown and the same three links become a bullet list you can paste into a README or a release note:

- <https://example.com/blog/launch>
- <https://example.com/pricing>
- <https://example.com/docs/api>

No retyping, no missed comma, no broken bracket. The input is one source of truth; the output is whatever the destination needs.

Where each format earns its keep

The format you reach for usually matches a document you are about to fill in.

Sitemaps and crawl queues. A sitemap is already a list of URLs. Convert it to a JSON array and you have a ready seed list for a crawler, a link checker, or a screenshot job. Dedupe first so you do not crawl the same page twice.

Redirect tables and link docs. A redirect plan often starts as a column of old URLs in a spreadsheet. Convert it to Markdown and you get a readable link list to drop into a migration doc, where each URL is clickable during review. Convert it to CSV when you need the row numbers and validity reasons as an audit trail.

Database work. When you need to query rows that match a known set of URLs, the SQL IN output saves the tedious part: every value is already quoted and comma-separated inside the parentheses, so you paste it after WHERE url IN and run.

Typed code. The TypeScript union turns an allowlist of routes or domains into a string literal type, which means a typo anywhere downstream is a compile error rather than a silent miss.

How I use it on a redirect migration

When I move a site to new URLs, my starting point is always a messy column pasted out of a spreadsheet: some rows have trailing spaces, a few are duplicated, and one or two are not real URLs at all. I paste the whole thing in, turn on dedupe and sort, and keep invalid rows visible so I can see exactly which lines failed and why. Then I export CSV with the line numbers for the migration ticket, because that is the artifact reviewers want to check against. Right after that I flip to the Markdown output and drop the clean link list into the migration doc so the team can click through each old URL before we cut over. Same input, two artifacts, no hand-editing in between. The part I appreciate most is that none of those internal URLs ever go to a server.

Keeping the list honest

A couple of habits keep the output trustworthy. Copied web text often carries hidden whitespace, so normalize before you deduplicate, otherwise two visually identical URLs survive as separate rows. And remember that a URL parsing as valid only means the string is shaped like a URL; it is not proof that the page, domain, or resource exists. If you need that, a link checker is a separate step.

If your raw material is not a clean column yet, start one tool earlier. The Markdown link extractor pulls URLs out of [text](url) syntax in notes and docs, and from there you hand the flat list to the converter to reshape it into JSON, CSV, or a SQL clause.

A quick recipe

1. Paste your URLs, or load a local .txt or sitemap file.
2. Turn on dedupe and sort; keep invalid rows if you want an audit trail.
3. Pick the output: lines, CSV, JSON, Markdown, SQL IN, or TypeScript union.
4. Copy it, or download the exact file you need to hand off.

That is the entire loop. The converter does the bracketing, quoting, and link-wrapping that you would otherwise do by hand across dozens or hundreds of lines, and it does it on text that stays in your browser. Open the URL List Converter and paste your first list to see all six outputs side by side.

---

Made by Toolora · Updated 2026-06-13