Python Code to Markdown Documentation Generator

Instantly transform Python source code into clean, structured Markdown documentation. This tool parses your code's Abstract Syntax Tree (AST) to automatically extract module docstrings, class definitions, methods, and function signatures into a readable format.

This Actor turns raw Python source code into a clean, navigable Markdown reference by reading the code's own structure rather than relying on regex or guesswork. It inspects each module's docstring, every top-level and nested function signature, and every class along with its methods, then renders them into a consistent documentation layout that is easy to read, copy into a wiki, or publish alongside a repository. The result is documentation that reflects exactly what is written in the code, with no manual transcription required.

Use Cases

• Generating API reference pages for a Python library by feeding the source of each module and producing a Markdown file with every public function signature and its associated docstring.
• Documenting a class hierarchy for onboarding where each class is rendered with its docstring as a section header and its methods are listed underneath with their argument names, making it easy for new contributors to see what a class exposes.
• Auditing docstring coverage across a codebase by quickly producing a Markdown view of every function and class and identifying which entries have empty docstring fields returned by the parser.
• Creating teaching materials or code walkthroughs that pair each function definition, including its parameter list extracted from ast.args.args, with its inline documentation in a single, readable document.
• Bootstrapping initial documentation for legacy scripts that lack any external docs, by parsing the existing module, function, and class docstrings into a structured Markdown starting point that can then be edited and expanded.

How It Works

The Actor accepts a JSON payload containing the Python source under a source or code key, plus an optional format flag, and begins by running ast.parse to convert the code into an Abstract Syntax Tree, returning a syntax error message if the code is invalid. It then extracts the module-level docstring with ast.get_docstring, walks the tree to collect every FunctionDef and ClassDef, and for each node captures the name, argument list from node.args.args, and docstring. Classes are processed recursively so that their method definitions are nested under the class as a list of name, signature, and docstring entries. Finally, it iterates over the collected items and, when format is set to markdown, emits a single Markdown document with a top-level heading, the module docstring, and per-item sections formatted with backtick-wrapped signatures and dedented docstring bodies.

Usage on Apify

Run it directly from the Apify Console ("Start"/"Try for free"), or call it via the API:

POST https://api.apify.com/v2/acts/documentation-creation-toil/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
Content-Type: application/json
{}

Pricing

Pay-per-event, billed automatically by Apify -- no separate account or payment step:

• Actor start: $0.00005 per GB of memory (minimum one event per run)
• Result: $0.005 per item returned -- this is the primary, usage-based charge

Also independently available at $0.0100 USDC (Base) per call via the x402 payment protocol (POST /tools/documentation-creation-toil) for callers outside the Apify platform.

Example output

Real output captured from this tool's own build-time smoke test (input above):

{
  "documentation": "# Documentation\n\n",
  "summary": "Generated documentation for 0 items."
}