JSDoc to Markdown
Paste JavaScript or TypeScript with JSDoc and get clean, ready-to-ship Markdown API docs. The tolerant parser handles functions, classes and methods, and typedefs/interfaces across a broad tag set — @param (with {type}, [name=default] and nested options), @returns, @throws, @example, @template, @deprecated, @since, @see and access modifiers — emitting heading-per-symbol docs with signature blocks, parameter tables, async/deprecated badges and a linked table of contents. A live parse report shows every symbol found and flags params missing a description.
About this ToolHow it works, benefits & use casesTap to collapse
Paste JavaScript or TypeScript that contains JSDoc comments and this tool turns them into clean, ready-to-ship Markdown API documentation. A tolerant parser reads each /** ... */ block together with the declaration that follows it, so it can tell whether a symbol is a function, a class and its methods, a typedef, an interface, or a constant, and infer the signature from the source. It understands a broad tag set: @param (with {type}, optional [name=default] brackets, and nested options.x rows), @returns / @return, @throws, @example, @template, @deprecated, @since, @see, @default and the @public / @private / @protected access modifiers. For each symbol it emits a heading, an optional fenced signature block, a parameter table with Name, Type, Default and Description columns, returns and throws sections, examples as fenced code, async and deprecated badges, and — when more than one symbol is documented — a linked table of contents. A live parse report lists every symbol found and flags any parameter declared without a description. Choose GitHub-flavored or plain Markdown, set the heading level and title, toggle the table of contents, signature blocks, badges and private symbols, and the whole configuration is captured in a shareable URL. Conversion runs entirely in your browser.
How to Use
- 1Paste JavaScript or TypeScript containing JSDoc comments into the input, or load one of the examples (functions, a class with methods, or a typedef).
- 2The Markdown regenerates live as you type — no Run button needed.
- 3Tune the output style: GitHub vs plain flavor, heading level, title, table of contents, signature blocks, badges, and whether private symbols are included.
- 4Check the parse report for the symbols found by kind and any parameters missing a description.
- 5Copy the Markdown, download it as a .md file, or share the input and settings via the generated link.
Key Benefits
- Documents functions, classes and methods, typedefs, interfaces and constants from one paste
- Broad tag support: @param, @returns, @throws, @example, @template, @deprecated, @since, @see, @default and access modifiers
- Parameter tables with type, default and description, including nested options.x rows
- Async and deprecated badges, plus a linked table of contents for multi-symbol docs
- GitHub-flavored or plain Markdown, configurable heading level and title
- Live parse report surfaces every symbol and warns about undocumented parameters
- Shareable URL captures the source and every style option; fully in-browser
Common Use Cases
- Turning the JSDoc on a utility library into a README API reference
- Generating Markdown docs for a docs site from annotated source
- Producing a parameter table for a function to paste into a PR or design doc
- Surfacing @deprecated notices and version history in human-readable documentation
- Documenting an internal SDK or class without setting up a full doc-generation pipeline
Generated Markdown API reference
# API Reference
**Contents**
- [add](#add)
- [getUser](#getuser)
## function add
Calculate the sum of two numbers.
```ts
function add(a, b)
```
### Parameters
| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `a` | `number` | - | The first number. |
| `b` | `number` | - | The second number. |
### Returns
**Type:** `number` — The sum of a and b.
### Example
```js
add(5, 3); // => 8
```
---
## function getUser `⚠ deprecated` `async`
> **⚠️ Deprecated:** Use fetchUserById instead.
Fetch a user from the API.
```ts
async function getUser(userId, options = {})
```
### Parameters
| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `userId` | `string` | - | The user ID. |
| `options` _(optional)_ | `Object` | - | Optional configuration. |
| ↳ `options.cache` _(optional)_ | `boolean` | true | Enable caching. |
### Returns
**Type:** `Promise<Object>` — The user record.
### Throws
- `Error` — If the user is not found.
**See:** fetchUserById
**Since:** 1.2.0
Parse report
Source with JSDoc
Tip: keep each /** … */ block directly above its declaration so the parser can infer the signature and symbol kind.
Output style
top heading
when >1 symbol
fenced code
async / deprecated
@private symbols
A tolerant parser, not a strict one
Each /** … */ block is read together with the declaration that follows it, so the tool infers whether a symbol is a function, a class and its methods, a typedef or an interface — and emits a matching heading, signature and table.
Broad tag support
It understands @param (with {type}, [name=default] and nested options.x rows), @returns, @throws, @example, @template, @deprecated, @since, @see, @default and access modifiers, degrading gracefully on anything it does not recognise.
Was this tool helpful?
Share Your Experience
Help others discover this tool!
Related tools
- Markdown TOC GeneratorGenerate table of contents for Markdown
- Markdown to HTMLConvert Markdown to HTML
- HTML to MarkdownConvert HTML to Markdown
- Code Block FormatterFormat code blocks for Markdown
- Color ConverterConvert between HEX, RGB, HSL, and HSV
- cURL to Code ConverterConvert cURL commands to code in various languages
@param / @arg / @argument (with type, optional and default detection, nested options.x rows, and descriptions), @property / @prop for typedefs, @returns / @return, @throws / @exception, @example, @template / @typeparam, @see, @deprecated, @since / @version, @default, @async, and the @public / @private / @protected access modifiers. Anything it does not recognise is ignored rather than breaking the output.
It reads the source immediately after each comment block and matches common declaration forms — function name(), const name = () =>, class Name, interface Name and type Name — to infer both the symbol kind and its signature. Explicit tags like @typedef, @class, @interface or @function override the inference, and methods documented inside a class are grouped under their parent.