FlexDoc 2.8 · one renderer across the stack

Your OpenAPI spec should be more than a static reference.

FlexDoc is Prauga's open-source, self-hosted OpenAPI documentation renderer, Try It explorer and local API workspace. The 2.8 milestone closes broad framework coverage while keeping one canonical renderer and request model across docs, execution, API Client handoff, saved workspaces and generated code.

OpenAPI
3.0 + 3.1
Product milestone
2.8.0
Runtime CDN
None required
Install

Pick your framework. Get the exact setup.

FlexDoc 2.8 is a product milestone, not a forced package-version lockstep. Choose the framework you already run and get the independently versioned package, install command and minimal native integration for that stack.

Choose your stack

Install one adapter. Keep your framework.

FlexDoc 2.8 uses one renderer contract across independently versioned packages. Pick the framework you already run and this panel shows the package, exact version and smallest useful integration path.

Package
@prauga/flexdoc-client
v2.8.0
FlexDoc 2.8 ships FlexDoc, the low-level ApiClient and the persistent ApiClientWorkspace, including nested folders, collection variables, hierarchical auth and canonical Postman import.
1. Install the client
install
npm install @prauga/flexdoc-client@2.8.0
2. Mount FlexDoc
tsx
import { FlexDoc } from '@prauga/flexdoc-client';
import '@prauga/flexdoc-client/styles.css';

export function Docs({ spec }) {
  return <FlexDoc spec={spec} options={{ tryIt: { enabled: true } }} />;
}
Open /docs. Renderer assets are packaged locally with the selected integration, so no FlexDoc account or runtime CDN is required.
Real FlexDoc renderer · Chromium capture

See the full renderer, Try It and API Client workflow.

These screenshots are captured from this site running Prauga's canonical renderer with a full-surface OpenAPI setup: regional server variables, authentication, advanced parameters, nested schemas, Try It, live response inspection and generated request code. The images automatically match this site's light or dark theme.

Open the interactive demo
FlexDoc production-style API overview in light mode
Full API overview with navigation, OpenAPI metadata, multiple operations and configurable servers.
FlexDoc Try It request, response and code generation in light mode
Try It, end to end

The docs execute the request they describe.

The capture fills advanced request inputs, sends the request, renders the response and hands the exact built request into the editable API Client — all through the same canonical request model.

Try It → API Client5 auth familiesCustom serversAdvanced serializationResponse viewer5 code languages
API Client workspace

The complete local workspace ships in 2.8.

The published workspace layers collections, arbitrarily nested folders, collection and environment variables, hierarchical auth with OAuth grants, trusted scripts, persisted tests/history and Postman Collection v2.1/environment import around the same canonical HTTP editor used by Try It.

Open API Client workspace
FlexDoc 2.8 API Client workspace in light mode
FlexDoc today

The renderer grew into an API exploration engine.

FlexDoc 2.8 is the coordinated catch-up release for the API Client: nested workspaces, layered variables, inherited auth/OAuth, scripting, persisted tests/history, canonical Try It handoff and Postman import now ship together. The same renderer contract still spans React/Node and every supported native adapter without runtime CDN or hosted-service requirements.

A real Try It flow

Edit parameters, bodies and authentication, choose servers, send the request and inspect the live response without leaving the docs.

Try It → API Client

Snapshot the built OpenAPI request into an editable HTTP client with method, URL, query, headers, auth, body, custom servers and response inspection.

Postman import, canonically

Import Postman Collection v2.1 and environment exports into native FlexDoc collections, folders, variables, auth and scripts with explicit compatibility warnings.

One canonical renderer

React/Node, .NET, JVM, Python, PHP, Ruby, Go, Rust and Elixir hosts share the renderer contract instead of reimplementing OpenAPI behavior per framework.

OpenAPI 3.0 + 3.1

Normalization, composition, recursive schemas, local and relative external references, server variables and richer parameter serialization.

Request-derived code samples

cURL, JavaScript, Python, Go and Java samples are generated from the same canonical request model that powers Try It.

Search + deep links

Responsive navigation, endpoint search and stable operation hashes make large API references easier to browse and share.

Self-hosted by default

No FlexDoc account, hosted dashboard, telemetry service or runtime CDN is required. Renderer assets ship with the integration.

API key, Basic and Bearer auth plus OAuth/OpenID tokens; workspace auth inheritance and browser OAuth grants
Local API Client workspace with Postman import, nested folders, collection/environment variables, inherited auth, scripts, persisted tests and contextual history
JSON, form-urlencoded and multipart request bodies
deepObject, matrix, label, pipe/space-delimited and explode parameter semantics
light/dark themes plus typed renderer configuration
responsive mobile navigation and operation deep links
CLI local serving, static export and standalone JS/CSS for non-React hosts
2.8 published surface

One request model, from reference docs to a local API workspace.

FlexDoc 2.8 carries the complete 2.4–2.7 workspace work into one coordinated release and adds Postman import: nested collections, layered variables, hierarchical auth, OAuth grants, scripts, persisted tests/history, canonical Try It handoff and compatibility-aware migration all use the same request model.

Specifications & references

OpenAPI 3.0.x and 3.1.x in JSON or YAML
local JSON Pointer references, including escaped tokens
external, nested and circular $ref bundling, including references back to the root document
referenced parameters, request bodies and responses
recursive component schemas without infinite expansion

Servers & parameters

root, path and operation server precedence
server variables with defaults/enums plus arbitrary custom server overrides
query form arrays/objects with explode true or false
spaceDelimited, pipeDelimited and flat deepObject query serialization
simple, label and matrix path serialization
header and cookie parameters plus allowReserved values

Authentication & security

Bearer and Basic HTTP authentication
API keys in header, query and cookie locations
OAuth2 and OpenID Connect access-token injection from OpenAPI Try It
OpenAPI security OR alternatives and multi-scheme AND requirements
API Client collection/folder/request auth inheritance with explicit No auth overrides
API Client OAuth manual tokens, Authorization Code + PKCE, Client Credentials, Password, Implicit and refresh-token reuse
request interceptors and configurable Fetch credentials behavior

Bodies, responses & schemas

JSON, application/x-www-form-urlencoded and multipart/form-data bodies
response status, headers and body inspection
allOf, oneOf and anyOf composition plus recursive schemas
OpenAPI 3.0 nullable and OpenAPI 3.1 type arrays containing null
const, enum, defaults, examples and schema-valued additionalProperties

Docs, Try It & code generation

responsive reference UI, endpoint search and stable deep links
Try It request editing and execution from OpenAPI operations
canonical Try It → API Client sessions preserving server and authorization context
cURL, JavaScript, Python, Go and Java samples from the same canonical request
light/dark themes, logos, CSS/theme tokens, tag groups, extensions and renderer options
renderer expansion defaults and viewer settings exposed across adapter configuration

Local API Client workspace

arbitrary HTTP requests with editable URL, query, headers, auth and bodies
collections, arbitrarily nested folders and reusable saved requests
collection variables plus named environments with deterministic {{variable}} precedence
trusted pre-request JavaScript with run-local, collection and environment variables
response tests/assertions plus captured script console output
request history with resolved execution metadata, test results/logs, collection/folder identity and raw-template replay
Postman Collection v2.1 and environment import into the canonical workspace with explicit compatibility warnings
browser-local IndexedDB persistence with configurable workspace keys
Framework coverage

Native framework boundaries, not renderer forks.

FlexDoc keeps each ecosystem's own OpenAPI generator and HTTP primitives. Thin hosts serve the same packaged renderer contract, so adding a framework does not mean rebuilding navigation, schemas, Try It or the API Client.

Browser / NodeReact + standalone rendererExpress · Fastify · NestJS · Hono
.NETASP.NET Core endpoint routingASP.NET Core 8+
JVMframework-neutral host + Jakarta transportSpring Boot · JAX-RS · Quarkus · Micronaut · Guice/Governator · Ktor
Pythonneutral host + ASGI / WSGI transportsFastAPI · Starlette · Flask · Django
PHPframework-neutral PHP hostLaravel · Symfony
Rubyhost + Rack transportRack · Rails
Gostandard net/http handlernet/http · Gin · Chi · Echo v5 · Fiber v3
Rustnative transport cratesAxum · Actix Web
ElixirPlugPlug · Phoenix
CLI / staticJSON or YAML documentlocal serve/watch · self-contained static export

Deliberate boundaries

OpenAPI Try It itself uses supplied OAuth/OpenID tokens; interactive OAuth grant acquisition lives in the API Client workspace and requires browser-compatible redirect/CORS behavior.

OAuth client secrets entered in the browser are not confidential. Token acquisition/refresh is explicit, and expires_in is informational rather than an automatic refresh scheduler.

deepObject is first-class for flat object properties; nested deep-object expansion is not recursive.

multipart requests use FormData, but binary file picking is not yet a first-class renderer control.

patternProperties / JSON Schema conditionals, webhooks, callbacks and XML metadata are retained or partially modeled but are not complete first-class interactive surfaces.

Postman multipart/file fields cannot recreate browser File objects; they import as reviewable text with compatibility warnings, and unsupported Postman sandbox/auth behavior is never silently treated as equivalent.

API Client scripts are trusted local JavaScript, not a security sandbox. Persisted workspace secrets are stored as entered in the browser origin.

template expansion is one pass; request chaining (flex.sendRequest), cookie scripting APIs and external package imports remain future scripting layers.

Swagger/OpenAPI 2.0 is not accepted; integrations should generate OpenAPI 3.x.

Architecture

One renderer. Many ways to ship it.

Framework adapters no longer implement their own parsing, schemas, code generation or Try It behavior. They obtain the OpenAPI document and host version-matched FlexDoc renderer assets.

React component plus standalone browser renderer
Express, Fastify, NestJS and Hono on Node
.NET, JVM, Python, PHP, Ruby, Go, Rust and Elixir hosts
CLI/static export and self-contained assets with no runtime CDN
Renderer flow
OpenAPI document
normalization + reference resolution
canonical renderer + request model
React / Node
.NET / JVM
Python / PHP / Ruby
Go / Rust / Elixir

Designed to self-host cleanly

FlexDoc renderer assets are packaged with the integration. Documentation-route credentials are validated server-side and are not serialized into browser configuration. You control the API, the docs route and the deployment.

API Client grew into a local workspace

The browser workspace persists collections, nested folders, saved requests, collection/environment variables, layered auth, scripts, response tests and contextual request history locally. Try It hands off a canonical session with request, server and supported authorization context so workspace features build on request semantics instead of duplicating them.

Open the spec. Explore it. Call it.

FlexDoc 2.8 is open source under AGPL-3.0-or-later. Use the live demo, use the install selector above, or inspect the architecture on GitHub.