How to expand reference links to inline for renderers
- Step 1Load the Markdown — Paste the reference-style document or drop a
.md/.mdx/.markdownfile that has a definition block. - Step 2Set Convert to Reference → Inline — Flip the single Convert dropdown to Reference → Inline (
to-inline). It defaults to the opposite direction, so this switch is required. - Step 3Run the expansion — Click Run. Definitions are collected first, then every full and collapsed reference is resolved to inline
[text](url). - Step 4Confirm everything resolved — Each matched link should now read
[text](url). Scan for leftover[text][id]— those are references whose id had no definition, left untouched on purpose. - Step 5Note the stripped definition block — All
[id]: urllines are gone and extra blank lines collapse. The result is plain inline Markdown ready for any renderer. - Step 6Render or validate — Render in your target system, or run the link validator first to confirm every expanded URL resolves.
What expands and what doesn't
Only full and collapsed reference forms expand. Definition lines are removed in every case, which is why shortcut links need attention.
| Reference form | Expands? | Result |
|---|---|---|
[text][1] (full, defined) | Yes | [text](url) |
[text][] (collapsed, defined) | Yes — text is the id | [text](url) |
[Text][API] with [api]: url | Yes — case-insensitive | [Text](url) |
[text][1] with [1]: url "T" | Yes — double-quote title kept | [text](url "T") |
[text][9] undefined | No | [text][9] unchanged |
[text] shortcut | No — not a full reference | [text] (def still removed) |
Renderer reality check
Most modern renderers support reference style. Verify your target rather than assuming it doesn't — expand only when you have confirmed a real limitation or want self-contained snippets.
| Target | Reference support | Reason to expand anyway |
|---|---|---|
| GitHub / GitLab | Full | Copying one section without its definition block |
| Pandoc / CommonMark | Full | Rarely needed; round-tripping for edits |
| Minimal / custom parsers | Varies | Some only implement inline links |
| Chat / paste targets | Often none | Pasting a snippet that loses its bottom block |
| Email / plain-text export | None | Inline keeps URL beside text |
Tier limits
charLimit is a character count distinct 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
Reference-style input expanded to inline. Notice the definition block is gone every time and self-contained links remain.
Expanding numbered references for a snippet copy
You want to copy one section into a chat or a parser that drops the bottom block. Expanding first makes the snippet self-contained.
BEFORE: See [setup][1] then [deploy][2]. [1]: https://acme.dev/setup [2]: https://acme.dev/deploy AFTER: See [setup](https://acme.dev/setup) then [deploy](https://acme.dev/deploy).
Collapsed reference expanded
A collapsed reference uses its visible text as the id. With a matching definition, it expands like any full reference.
BEFORE: The [Changelog][] lists every release. [changelog]: https://acme.dev/changelog AFTER: The [Changelog](https://acme.dev/changelog) lists every release.
Title carried inline
Double-quote titles in the definition are preserved on the expanded inline link.
BEFORE: Read [the guide][1]. [1]: https://acme.dev "Style Guide" AFTER: Read [the guide](https://acme.dev "Style Guide").
Undefined reference left intact
Expansion never guesses. A reference with no definition is preserved so you can see exactly what's missing before rendering.
BEFORE: See [the API][api] and [the SDK][sdk]. [api]: https://acme.dev/api AFTER: See [the API](https://acme.dev/api) and [the SDK][sdk]. (the SDK reference had no definition — left as-is)
Shortcut link does not expand
A shortcut [text] is not expanded, yet its definition is removed — leaving plain text. Convert shortcuts to full [text][id] form before expanding for legacy rendering.
BEFORE: Visit the [Docs] page. [docs]: https://acme.dev/docs AFTER: Visit the [Docs] page. (the [docs]: definition is gone; [Docs] now renders as plain text)
Edge cases and what actually happens
Shortcut reference link [text]
Not expandedExpansion handles only [text][id] and [text][]. A shortcut [text] is skipped, but its definition is still removed — so it ends up plain text with no URL. Rewrite shortcut links to full form before expanding, especially when targeting a legacy renderer that wouldn't have shown them anyway.
Undefined reference id
Preserved[text][missing] with no definition is left exactly as written. For renderer compatibility this is the safe choice — better an obvious unexpanded reference than a fabricated URL. Search for leftover ][ after expanding to catch these before rendering.
Single-quoted title in the definition
Not parsedDefinition parsing recognises only double-quote titles. A definition like [1]: url 'Title' fails to match, so [1] is never registered and its link stays unexpanded. Switch the title to double quotes, or remove it, before expanding.
Definition URL with whitespace
TruncatedThe URL is read as a single non-whitespace run, so a definition URL containing a literal space stops at the space and the expanded link loses the tail. Percent-encode spaces as %20 in the definition first.
Orphan definitions removed
RemovedEvery [id]: url line is stripped whether used or not. Unused or commented-out definitions vanish from the output — intended, since the goal is a clean inline document for the target renderer.
Duplicate definition ids
Last winsIf [1]: a appears before [1]: b, links resolve to b (the later definition overwrites). Both lines are then removed. Deduplicate your definition block first if the repeat was accidental.
Reference inside a code block
ExpandedNo fence awareness — a reference written inside a ``` block or inline code is expanded too. If you're documenting reference syntax for the target system, escape the example or expand before adding it.
Modern renderer that already supports references
UnnecessaryGitHub, GitLab, Pandoc, and most CommonMark engines render reference links natively, so expansion is not required for them. Confirm your target actually lacks support before expanding — the main legitimate reasons are minimal parsers and copying snippets that would lose their definition block.
File over the tier limit
413 rejectedFree caps each file at 1 MB / 500,000 characters. A large reference-heavy document may hit the character cap first. Split with the splitter and expand per part, or upgrade for higher ceilings.
Frequently asked questions
Which renderers actually need expanded links?
Most modern ones (GitHub, GitLab, Pandoc, CommonMark engines) support reference style natively, so they don't. Expansion matters for minimal or custom parsers that only implement inline links, and for copying a single section into a chat or paste target that would otherwise drop the bottom definition block. Verify your target before expanding.
What reference forms does expansion resolve?
Full references [text][id] and collapsed references [text][] (text reused as the id). Shortcut links [text] are not expanded. All resolution is against the [id]: url definition block, matched case-insensitively.
Will expansion fail for orphan references?
It won't fail — undefined references are left untouched, exactly as written. Nothing is guessed or dropped. After expanding, scan for any remaining [text][id] to find references whose definition was missing.
Why didn't my [Docs] shortcut link expand?
Because shortcut links (no second bracket) aren't expanded — only [text][id] and [text][] are. And since the definition line is removed regardless, [Docs] is left as plain text. Rewrite it to [Docs][docs] before expanding.
Are link titles preserved?
Yes, if the definition uses double quotes: [1]: url "Title" expands to [text](url "Title"). Single-quote titles aren't parsed — that definition fails to match and the link stays unexpanded. Use double quotes.
Does it remove the definition block?
Yes — every [id]: url line is removed and runs of blank lines collapse. That's the point of expanding: each link becomes self-contained inline, with no trailing reference data.
Can I check coverage after expansion?
Yes. Run the link validator on the expanded output to confirm every inline URL resolves. Combine that with a quick search for leftover ][ to catch any references that didn't expand because their definition was missing.
Is id matching case-sensitive?
No. Definition and reference ids are both lowercased before matching, so [Client][API] resolves against [api]: url. This matches CommonMark's case-insensitive label rules.
Will references inside code blocks be expanded?
Yes — there's no fence awareness, so a reference in a fenced ``` block or inline code is expanded. Escape or relocate any documentation example that must stay literal in the target renderer.
Can I reverse this back to reference style?
Yes — set the Convert dropdown to Inline → Reference. For a clean round trip, keep titles in double quotes and use full reference forms; shortcut links and single-quote titles are the two things that don't survive intact.
Is my content uploaded anywhere?
No. Expansion runs in your browser. Pro+ can route to the local runner, which still runs on your machine. Only an anonymous run counter is recorded for signed-in dashboard stats.
How large a document can it expand?
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. The character cap often binds first on reference-heavy docs.
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.