# Generate SDK reference pages from doc-tool output (/api-playground/sdk-reference-setup)

<!-- agent-signals: reading_time_min: 3 · est_tokens: 1496 · updated: 2026-07-30 -->
Related: [API playground overview](/api-playground/overview.md), [OpenAPI setup](/api-playground/openapi-setup.md), [Complex data types](/api-playground/complex-data-types.md), [Add SDK examples](/api-playground/adding-sdk-examples.md), [Manage page visibility](/api-playground/managing-page-visibility.md), [Multiple responses](/api-playground/multiple-responses.md)

Use the `sdk` navigation property to generate reference pages for your SDK libraries from the documentation tools you already run. Mintlify reads each tool's build artifact and creates a page for every class, interface, module, and function, with navigation groups, cross-page links, and search indexing included.

## Supported formats [#supported-formats]

| `format`  | Tool                                                                             | Artifact                                                  |
| --------- | -------------------------------------------------------------------------------- | --------------------------------------------------------- |
| `typedoc` | [TypeDoc](https://typedoc.org) (TypeScript/JavaScript)                           | JSON export file                                          |
| `docfx`   | [DocFX](https://dotnet.github.io/docfx/) (.NET)                                  | `docfx metadata` output directory (ManagedReference YAML) |
| `javadoc` | [Javadoc](https://docs.oracle.com/en/java/javase/17/javadoc/javadoc.html) (Java) | Standard doclet HTML directory                            |
| `sphinx`  | [Sphinx](https://www.sphinx-doc.org) (Python)                                    | JSON builder output directory                             |
| `phpdoc`  | [phpDocumentor](https://phpdoc.org) (PHP)                                        | `structure.xml` file                                      |

## Generate an artifact [#generate-an-artifact]

Run your documentation tool with a machine-readable output format. If you already publish generated docs from CI, this is usually a one-flag change to the same command.

<CodeGroup>
  <CodeBlockTabs defaultValue="TypeDoc" groupId="docfx+javadoc+phpdocumentor+sphinx+typedoc">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="TypeDoc">
        TypeDoc
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="DocFX">
        DocFX
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Javadoc">
        Javadoc
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Sphinx">
        Sphinx
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="phpDocumentor">
        phpDocumentor
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="TypeDoc">
      ```bash  
      npx typedoc --json typedoc.json src/index.ts
      ```
    </CodeBlockTab>

    <CodeBlockTab value="DocFX">
      ```bash  
      docfx metadata docfx.json
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Javadoc">
      ```bash  
      javadoc -d javadoc-output -sourcepath src/main/java -subpackages com.example
      # Or download the published javadoc jar from Maven Central
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Sphinx">
      ```bash  
      python -m sphinx -b json docs/source artifacts/json
      ```
    </CodeBlockTab>

    <CodeBlockTab value="phpDocumentor">
      ```bash  
      phpdoc -d src -t artifacts --template=xml
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

## Auto-populate SDK pages [#auto-populate-sdk-pages]

Add an `sdk` property to a tab in your `docs.json`. Mintlify parses the artifact and creates navigation groups and pages for the library.

```json
"navigation": {
  "tabs": [
    {
      "tab": "SDK Reference",
      "sdk": {
        "format": "typedoc",
        "source": "sdk-artifacts/typedoc.json",
        "directory": "sdk/typescript"
      }
    }
  ]
}
```

<Note>
  You must declare `sdk` on a [tab](/organize/navigation#tabs). A tab with `sdk` may include `groups`, but no other navigation structures, such as `pages`, `versions`, or `languages`. It also cannot include an `openapi`, `asyncapi`, or `graphql` property.
</Note>

<ParamField path="format" type="string">
  The documentation tool that produced the artifact: `typedoc`, `docfx`, `javadoc`, `sphinx`, or `phpdoc`.
</ParamField>

<ParamField path="source" type="string">
  Relative path to the artifact file or directory in your docs repository, or an HTTPS URL. Does not accept HTTP URLs.
</ParamField>

<ParamField path="directory" type="string">
  The URL path prefix for generated pages. Defaults to `sdk-reference`.
</ParamField>

Add multiple tabs to document multiple libraries. Use a unique `directory` for each library to avoid route collisions.

<Tip>
  Add your artifact directory to [`.mintignore`](/organize/mintignore) so Mintlify treats artifacts as build inputs rather than publishing them as static assets.
</Tip>

## Generated pages [#generated-pages]

Mintlify adds the generated navigation groups after any `groups` on the tab. The groups vary by format and may represent modules, packages, namespaces, or symbol types.

Each generated page documents a class, interface, function, type, or other symbol from the artifact and links to related generated pages. If a converter produces pages that do not belong to a group, Mintlify collects them under a `Reference` group.

## Use remote sources [#use-remote-sources]

Set `source` to an HTTPS URL to fetch the artifact at build time instead of committing it to your docs repository.

Single-file formats (`typedoc`, `phpdoc`) accept a direct file URL. Directory formats (`docfx`, `javadoc`, `sphinx`) accept a zip archive. Javadoc jars published to Maven Central work without repackaging:

```json
{
  "tab": "Java SDK",
  "sdk": {
    "format": "javadoc",
    "source": "https://repo1.maven.org/maven2/com/example/my-library/1.0.0/my-library-1.0.0-javadoc.jar",
    "directory": "sdk/java"
  }
}
```

Remote artifacts have a 50 MB download limit and a 200 MB extracted size limit.

## Keep references up to date [#keep-references-up-to-date]

Regenerate the artifact whenever your SDK changes. A common pattern is a CI job in each SDK repository that runs the documentation tool on release. The job either commits the artifact to your docs repository or uploads it to a stable URL that `source` points to.