How to centralize link urls at document bottom
- Step 1Load the document — Paste the Markdown or drop a
.md/.mdx/.markdownfile whose URLs you want to centralise. - Step 2Keep Convert on Inline → Reference — The Convert dropdown defaults to
to-reference, which is the centralising direction. Leave it set there. - Step 3Run the conversion — Click Run. Each unique URL is numbered in first-seen order and rewritten to
[text][n]; the definition block is appended at the end. - Step 4Read the consolidated block — Scroll to the bottom. Every distinct URL is on its own
[n]: urlline. This is your full external-dependency surface in one place. - Step 5Audit or bulk-edit — Scan for risky domains, mixed
http/https, or tracking query strings. To migrate a domain, edit the one definition line rather than every inline link. - Step 6Validate the centralized links — Run the link validator on the result to check every URL in the block still resolves, and the secret redactor if any URLs carry tokens.
What centralizing buys an audit
Each documentation-hygiene task mapped to how reference style makes it easier.
| Audit task | Inline pain | After centralizing |
|---|---|---|
| Domain migration (acme.dev → acme.io) | Find-and-replace across the whole body, risk of partial matches in prose | Edit only the definition lines for that domain |
| Spot insecure links | http:// hidden mid-sentence anywhere | All URLs in one block — scan for http:// at a glance |
| Find tracking parameters | ?utm_... buried inline | Visible in the consolidated [n]: url lines |
| Count external dependencies | Manual scan of the entire document | Count the deduplicated definition lines |
| Remove a dead domain entirely | Hunt every occurrence | One definition removed; references then render as plain text (fix or repoint) |
Centralization behaviour and gotchas
How the to-reference pass treats each situation relevant to auditing.
| Situation | Behaviour |
|---|---|
| Same URL linked many times | Collapsed to one numbered definition (deduped by exact string) |
| URL differing only by trailing slash | Treated as two distinct URLs → two definitions |
URL containing a ) | Truncated at the first ) — fix or percent-encode |
Existing [1]: definition in the file | Collision — generated numbering also starts at 1 |
| Image links | Centralised too — ![alt][n] with [n]: url |
| Autolinks / bare URLs | Not centralised — they aren't [text](url) syntax |
Tier limits
charLimit is a character count separate from file size. One file per run on Free.
| Tier | Max file size | Max characters | Files per run |
|---|---|---|---|
| Free | 1 MB | 500,000 | 1 |
| Pro | 10 MB | 5,000,000 | 10 |
| Pro-media | 50 MB | 20,000,000 | 50 |
| Developer | 500 MB | unlimited | unlimited |
Cookbook
Audit-oriented scenarios. The payoff is always the same: one block you can read and edit instead of URLs scattered through the body.
A repeated domain collapses to one definition
A doc links the vendor's site four times. After centralizing, one [1]: line owns that domain — migrating it is a single edit.
BEFORE: [pricing](https://vendor.com/pricing), [docs](https://vendor.com/docs), [status](https://vendor.com/status), [blog](https://vendor.com/blog) AFTER: [pricing][1], [docs][2], [status][3], [blog][4] [1]: https://vendor.com/pricing [2]: https://vendor.com/docs [3]: https://vendor.com/status [4]: https://vendor.com/blog (all four share the vendor.com domain — one place to audit it)
Spotting insecure and tracked links in the block
Once centralized, an http:// link and a UTM-tagged URL stand out immediately in the definition block where they were invisible inline.
AFTER (definition block excerpt): [1]: https://acme.dev/docs [2]: http://legacy.acme.dev/old <- insecure, fix to https [3]: https://acme.dev/r?utm_source=md <- tracking param, strip? [4]: https://partner.example/api
Counting external dependencies
The number of deduplicated definition lines is your external-dependency count. Useful for a supply-chain or compliance review of what a doc points at.
AFTER (tail): [1]: https://github.com/acme/cli [2]: https://npmjs.com/package/acme [3]: https://crates.io/crates/acme [4]: https://hub.docker.com/r/acme/cli => 4 distinct external dependencies in this document.
Migrating a domain after centralizing
With every URL in one block, a domain move is a controlled edit of the definitions only — the body's [text][n] references are untouched.
BEFORE (block): [1]: https://acme.dev/docs [2]: https://acme.dev/api EDIT the two lines: [1]: https://acme.io/docs [2]: https://acme.io/api (body references [..][1], [..][2] need no changes)
Centralizing a doc that mixes images and links
Image URLs join the same block, so a media-asset audit (which CDN, which sizes) reads alongside the text links.
BEFORE:  and [more](https://acme.dev/more) AFTER: ![hero][1] and [more][2] [1]: https://cdn.acme.dev/hero.png [2]: https://acme.dev/more
Edge cases and what actually happens
Existing reference definitions in the file
CollisionCentralizing numbers URLs from 1 and ignores any [n]: url definitions already present, so a partly-referenced doc ends up with duplicate [1]: lines and ambiguous references. For a clean audit, centralize a fully-inline document, or convert existing references to inline first with the reverse direction.
URL containing a closing parenthesis
TruncatedA URL with ) in it (Wikipedia disambiguation links, some analytics URLs) truncates at the first ), so the centralized definition is incomplete and a stray ) is left in the prose. Percent-encode inner parens (%28/%29) before centralizing, then re-audit the block.
Trailing-slash and case variants count as separate URLs
By designDeduplication is exact-string, so https://x.com, https://x.com/, and https://X.com become three definitions. For an audit this is honest (they are technically different resources) but can inflate your dependency count — normalize URLs upstream if you want them merged.
Removing a definition breaks its references
Plain textIf you delete a definition to drop a dead domain, the [text][n] references that pointed to it have no target and most renderers show them as literal text. Repoint the definition or convert those references to inline with a replacement URL instead of deleting outright.
Query strings make 'same page' URLs distinct
By designhttps://x.com/p and https://x.com/p?utm_source=md are different strings, so they get separate definitions. Good for spotting tracking params; if you want them merged, strip the query strings before centralizing.
Autolinks and bare URLs are not centralized
PreservedAngle-bracket autolinks <https://x.com> and bare pasted URLs stay inline because they aren't [text](url) links. A complete audit should also scan for these — they won't appear in the consolidated block.
Links inside code samples get centralized
ConvertedNo fence awareness means an example URL inside a ``` block is pulled into the definition block too, inflating the audit with non-dependency URLs. Move documentation examples out of fences, or note which block entries came from code samples.
Secrets or tokens in URLs
Exposed in blockCentralizing surfaces any URL that carries an API key or token in a query string — now plainly visible in the bottom block. That's good for catching them, but redact before committing: run the secret redactor on the result.
File over the tier limit
413 rejectedFree caps each file at 1 MB / 500,000 characters. A large internal handbook may exceed the character cap. Split with the splitter and centralize per part, or upgrade for higher ceilings.
Frequently asked questions
How does centralizing help with audits?
It puts every link URL in one deduplicated block at the document bottom. Instead of hunting the body, you scan a single list for risky domains, insecure http:// links, tracking parameters, or dependencies you want to drop. The body keeps only [text][n], so prose stays readable during review.
Does it deduplicate URLs?
Yes — by exact string. A URL linked many times collapses to a single numbered definition, which is what makes domain migrations a one-line edit. Note that trailing-slash, case, and query-string variants count as different URLs and get separate definitions.
How do I migrate a domain after centralizing?
Edit only the definition lines for that domain — the body's [text][n] references don't change because they point at the number, not the URL. This is the central advantage of reference style for URL management.
What if a URL has a parenthesis in it?
It truncates at the first ), so the centralized definition is incomplete. Percent-encode inner parens before centralizing, then re-check the block. This mostly affects Wikipedia disambiguation links and some analytics URLs.
Can I integrate this with the link validator?
Yes — and it's the recommended workflow. Centralize first so every URL is in one block, then run the link validator to confirm each one resolves. Reviewing failures in a consolidated block is far faster than chasing inline links.
Will it catch tokens or secrets in URLs?
It surfaces them — any URL carrying a key or token in its query string becomes plainly visible in the bottom block. That's useful for spotting leaks, but redact before committing with the secret redactor.
What about my document already having some references?
Numbering restarts at 1 and ignores existing definitions, so you'd get duplicate [1]: lines. For a clean audit, centralize a fully-inline document. If the file is mixed, convert existing references to inline first using the reverse direction.
Are autolinks and bare URLs included?
No. Only [text](url) links are centralized. Angle-bracket autolinks <https://x.com> and bare URLs stay inline and won't appear in the block, so a thorough audit should scan for them separately.
Will example URLs in code blocks pollute my audit?
They can — there's no fence awareness, so a sample URL inside a ``` block is pulled into the definition block. Move documentation examples out of fences before centralizing, or mark which block lines came from code.
Is the document uploaded anywhere?
No. Centralizing runs in your browser; Pro+ may route to the local runner on your own machine. Only an anonymous run counter is stored for signed-in dashboard stats — relevant when the document is internal or sensitive.
How large a document can it process?
Free: 1 MB / 500,000 characters / 1 file. Pro: 10 MB / 5,000,000 / 10. Pro-media: 50 MB / 20,000,000 / 50. Developer: 500 MB and unlimited characters. Long handbooks often hit the character cap first.
How do I count my external dependencies?
After centralizing, count the deduplicated definition lines — each is one distinct URL the document points at. Filter for off-domain hosts to get external-only dependencies for a supply-chain or compliance review.
Privacy first
All Markdown processing runs locally in your browser using JavaScript. No file is ever uploaded to JAD Apps servers — only metadata counters are saved for signed-in dashboard stats.