How to convert markdown to jira / confluence wiki markup
- Step 1Paste or upload your Markdown — Use the Paste text tab to drop a ticket description or runbook, or Upload file to load a
.md,.mdx,.markdown, or.txtfile. Only one file is accepted — this tool does not batch multiple files. - Step 2Click Run — The converter applies its fixed substitution passes in order: fenced code is stashed first, then headings, then inline formatting, lists, blockquotes, and rules. There are no options to configure — the transform is deterministic.
- Step 3Review the output panel — The result renders as plain Jira wiki text. Check that bold collapsed to single asterisks and code fences became
{code}macros. Tables and images, if present, will look unchanged — that is expected (see the edge-cases section). - Step 4Copy to clipboard — Click Copy. The full wiki-markup string is placed on your clipboard, ready for the next step.
- Step 5Paste into Jira's wiki / text mode — In a Jira description or comment, switch the editor to the text / wiki-markup mode (depending on your Jira version) before pasting. Pasting wiki markup into the rich-text editor will show literal
h1.and*characters instead of formatting. - Step 6Verify rendering and fix tables manually — Toggle back to the rendered view to confirm. If your source had GFM tables, rebuild them in Jira's
||header||/|cell|syntax by hand — the converter does not transform tables. Download the-jira.txtcopy if you want it tracked next to the source.
What the converter actually maps
Every substitution the mdToJira transform performs, in the order it runs. Constructs not listed here pass through unchanged.
| Markdown construct | Jira wiki output | Notes |
|---|---|---|
# H1 … ###### H6 | h1. H1 … h6. H6 | Matched at line start only; deepest heading (######) is checked first so prefixes don't collide |
**bold** | *bold* | Jira uses a single asterisk for bold — the opposite of Markdown |
*italic* or _italic_ | _italic_ | Single-asterisk italic and underscore italic both become underscore italic |
~~strike~~ | -strike- | Jira uses a single hyphen pair for strikethrough |
code ` (inline) | {{code}} | The {{…}} monospace macro |
` lang ``` fenced block | {code:lang}…{code} | Stashed before inline rules run; bare ``` (no language) becomes {code}` |
[text](url) | [text|url] | Pipe-delimited Jira link form |
- item / * item / + item | * item | Two leading spaces per nesting level → one * repeated for depth |
1. item | # item | Ordered lists use #; nesting follows the same two-space rule |
> quote | bq. quote | Applied per line; each quoted line needs its own > |
--- / *** (3+ chars) | ---- | Horizontal rule |
What is NOT converted
These constructs have no handling in the transform and need a manual step in Jira. Documenting them up front avoids surprise on paste.
| Construct | What happens | Manual fix |
|---|---|---|
| GFM pipe tables | Pass through as raw | a | b | rows — Jira renders them as plain text | Rebuild in Jira's ||h1||h2|| header + |c1|c2| cell syntax |
Images  | The [alt](url) part matches the link rule, producing ![alt|url] — not Jira's !url! embed | Replace with Jira's !url! form, or drag-drop the image as a Jira attachment |
Task lists - [ ] / - [x] | The - becomes * , leaving * [ ] task — checkboxes are not native Jira wiki syntax | Remove the [ ] markers or use a Jira checklist app |
Footnotes [^1] | Left as literal [^1] text | Inline the note or use a Confluence footnote macro |
| Auto-links / bare URLs | Passed through; Jira auto-links bare URLs on its own | None needed in most Jira versions |
Tier limits for the input file
Markdown-family limits from the JAD tier table. The character limit is separate from the byte limit — a paste can hit the char cap before the file-size cap.
| Tier | Max file size | Max characters | Files per run |
|---|---|---|---|
| Free | 1 MB | 500,000 | 1 |
| Pro | 10 MB | 5,000,000 | 10 (this tool uses 1) |
| Pro + Media | 50 MB | 20,000,000 | 50 (this tool uses 1) |
| Developer | 500 MB | Unlimited | Unlimited (this tool uses 1) |
Cookbook
Before/after snippets showing exactly what the transform produces. Output is plain text — what you see is what lands on your clipboard.
Headings, bold, and a link in one ticket description
The everyday case: a ticket body with a heading, emphasis, and a doc link. Note bold collapses from two asterisks to one, and the link flips to the pipe form.
Markdown in: ## Summary The **login** page 500s when the [SSO config](https://wiki/sso) is empty. Jira out: h2. Summary The *login* page 500s when the [SSO config|https://wiki/sso] is empty.
Fenced code block with a language tag
Fenced code is stashed before the inline passes, so the asterisks and backticks inside the code are never touched. The fence language carries into the macro.
Markdown in:
```python
def f(x):
return x ** 2 # not bold
```
Jira out:
{code:python}
def f(x):
return x ** 2 # not bold
{code}Nested unordered list
Two leading spaces equal one nesting level. The transform divides the indent length by two and repeats the bullet, so a two-space indent becomes a single extra asterisk.
Markdown in:
- Parent
- Child
- Grandchild
Jira out:
* Parent
** Child
*** GrandchildInline code, italic, and strikethrough together
Inline code becomes the {{…}} macro, italic becomes underscores, and strikethrough becomes single hyphens — all in one pass over the prose.
Markdown in:
Run `npm ci`, not ~~npm install~~. This is *important*.
Jira out:
Run {{npm ci}}, not -npm install-. This is _important_.A GFM table that the tool leaves alone
There is no table-handling code in the transform. The table passes through verbatim and renders as monospaced plain text in Jira unless you rebuild it. This is the single most common surprise.
Markdown in: | Env | Status | | --- | ------ | | prod | up | Jira out (unchanged — needs manual rebuild): | Env | Status | | --- | ------ | | prod | up | Manual Jira form: ||Env||Status|| |prod|up|
Edge cases and what actually happens
GFM pipe tables are not converted
By designThe transform has no table logic. A | col | col | table passes through as literal pipe text and Jira shows it as plain monospaced lines, not a grid. Rebuild it in Jira's ||header||header|| plus |cell|cell| syntax by hand. This corrects a claim in older copy that pipe tables auto-convert — they do not.
Markdown images become a broken link form
Manual fixAn image  is not handled as an image. The [alt](url) portion matches the link rule and produces ![alt|url], which is neither Markdown nor Jira's !url! embed. After converting, replace these with !url! or upload the image as a Jira attachment and reference it.
Pasted into the rich-text editor instead of wiki mode
Display issueIf you paste the output into Jira's WYSIWYG editor, you will see literal h1., *, and {code} characters because the editor treats them as plain text. Switch to the text / wiki-markup input mode for that field before pasting, then toggle back to verify.
Underscores in identifiers get read as italic
Watch outJira treats _ as italic. A snippet of prose containing user_id or MAX_RETRIES (outside a code fence) can render the middle as italic in Jira. Wrap such tokens in inline code in your source so they become {{user_id}}, which Jira renders as monospace and ignores the underscores.
Task-list checkboxes survive as stray brackets
Manual fix- [ ] do thing becomes * [ ] do thing because only the bullet marker is rewritten. Jira wiki markup has no native checkbox, so the [ ] / [x] text remains. Strip the brackets or use a Jira checklist app for interactive checkboxes.
Multi-line blockquote needs a marker on every line
Watch outThe blockquote rule matches > text line by line. A lazy Markdown blockquote where only the first line has > will convert just that line to bq.; continuation lines stay as plain prose. Prefix every quoted line with > in the source for a clean conversion.
Bold-inside-italic nesting can flatten
Watch outBecause **x** to *x* and *x* to _x_ run as separate regex passes, deeply nested or adjacent emphasis like ***both*** may not produce the combination you expect. Review mixed-emphasis spans in the output and adjust by hand if needed.
Empty paste produces empty output
ExpectedRunning with no input simply returns an empty string — there is nothing to convert. Paste your Markdown or select a file before clicking Run.
Free tier rejects files over 1 MB or 500,000 characters
Tier limitA large runbook or merged doc can exceed the Free cap of 1 MB / 500,000 characters. The character limit is checked independently of byte size, so a paste can hit it first. Split the document, or upgrade to Pro (10 MB / 5,000,000 chars) for larger inputs.
Frequently asked questions
Does it convert GFM tables to Jira table syntax?
No. The transform has no table handling — | col | col | rows pass through unchanged and render as plain monospaced text in Jira. Rebuild tables manually using Jira's ||header||header|| for the header row and |cell|cell| for body rows. If your real need is markdown-side table cleanup first, see md-table-repair.
Why is my bold showing as a single asterisk?
That is correct Jira syntax. Jira uses one asterisk for bold (*bold*) where Markdown uses two (**bold**). The converter intentionally collapses **x** to *x*. In Jira's rendered view it will display as bold.
What happens to fenced code blocks?
Each ``` lang block becomes {code:lang}…{code}, and a bare block (no language) becomes {code}…{code}`. Code is stashed before the inline passes run, so asterisks, underscores, and backticks inside the code are preserved exactly — they are never reinterpreted as formatting.
Do Markdown images convert to Jira's !url! embed?
No. There is no image handling.  ends up as ![alt|url] because the link rule matches the bracketed part. Replace these with Jira's !url! form after converting, or drag-drop the image as a Jira attachment, which is more reliable than hotlinking external URLs.
How are nested lists handled?
Indentation is interpreted as two spaces per level. The transform divides the leading-space count by two and repeats the bullet (* for unordered, # for ordered). So a two-space indent becomes **, four spaces becomes ***, and so on. If your source uses tabs or four-space indents, the depth may not map as expected — normalize to two-space indents first with md-prettifier.
Are there any options or presets?
No. This tool is a deterministic, fixed-rule transform with no configurable options. The same input always produces the same output. If you need to clean or normalize the Markdown before conversion, run a sibling tool such as md-lint or md-bold-italic-cleaner first.
Can I paste this straight into Jira's normal editor?
Switch the field to its text / wiki-markup input mode first. Pasting wiki markup into the rich-text (WYSIWYG) editor will show literal h1. and * characters. After pasting in wiki mode, toggle back to the rendered view to confirm formatting.
Does it preserve smart-commit references and issue keys?
Yes. Plain text — including issue keys like PROJ-123, smart-commit commands, and @-mentions — passes through unchanged. Jira auto-links issue keys and resolves mentions on its side once the text is in a ticket.
What output format do I get and how do I save it?
The output is plain text. Use the Copy button to put it on your clipboard, or Download to save a -jira.txt file (the original filename with -jira.txt appended). It is the same wiki markup either way.
Is my ticket content uploaded anywhere?
No. The conversion runs in your browser on a string. Ticket descriptions, internal URLs, and any customer details in repro steps never reach a server. Only an anonymous run counter is recorded for signed-in dashboard stats.
How big a document can I convert?
Free tier allows 1 MB / 500,000 characters in a single file. Pro raises this to 10 MB / 5,000,000 characters. The character limit is enforced separately from byte size, so a very dense paste can hit the char cap before the size cap. This tool processes one file at a time regardless of tier.
What if I'm targeting Confluence rather than Jira?
Confluence storage format differs from Jira wiki markup, but Confluence's Insert > Markup > Wiki Markup dialog accepts the same wiki syntax this tool produces. For Confluence-specific guidance see the Confluence page format guide. For other output targets, see md-to-slack, md-to-html, or md-to-docx.
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.