canonical: https://jentic.com/apis/openapi-generator.tech/openapi-generator

# Openapi Generator Tech OpenAPI Generator Online

OpenAPI Generator Online is the hosted REST surface of the open-source OpenAPI Generator project. It accepts an OpenAPI 3 document and returns a downloadable client SDK or server stub in any of the project's supported languages and frameworks. The 7-endpoint API exposes the list of available client and server generators, accepts generation requests, and returns a fileId that can be downloaded as a zip. The service is unauthenticated, which makes it suitable for build automation and agent-driven scaffolding.

## For AI agents

Generate client SDKs and server stubs from an OpenAPI 3 spec across many languages via 7 unauthenticated endpoints, then download the result as a zip.

## Scope

Does not host specs, run tests on generated code, or deploy artifacts - use for OpenAPI-to-SDK and OpenAPI-to-server-stub generation only.

## Capabilities

- List every supported client SDK language with one GET request
- List every supported server stub framework so an agent can pick a target
- Submit an OpenAPI 3 spec plus options and receive a fileId to download the client SDK
- Submit an OpenAPI 3 spec plus options and receive a fileId to download the server stub
- Inspect generation options for a chosen language or framework before kicking off a job
- Download the produced zip archive by fileId once the generation completes
- Drive code-generation steps in CI without managing the OpenAPI Generator JAR locally

## Use cases

### CI-Driven SDK Publishing

Regenerate language-specific client SDKs every time the upstream OpenAPI spec changes, then publish the artifacts to internal package registries. Build pipelines call `/api/gen/clients/{language}` with the latest spec, retrieve the fileId, download the zip, and push to npm, PyPI, or Maven. Because no authentication is required, the integration is a single HTTP call with no key rotation overhead.

Example prompt: POST the latest openapi.yaml to `/api/gen/clients/python`, capture the fileId from the response, then GET `/api/gen/download/{fileId}` and unzip the artifact for upload to PyPI.

### Server Stub Bootstrapping

Bootstrap a service skeleton from an OpenAPI design document by generating a Spring, FastAPI, or aspnetcore server stub through the Online API. The result is a runnable starting point with controllers and models matching every operation in the spec, removing days of boilerplate. Agents can pick the framework with `/api/gen/servers` and submit the spec with `/api/gen/servers/{framework}.`

Example prompt: POST the openapi.json to `/api/gen/servers/spring` with options.basePackage='com.example.api', then download the resulting fileId zip and commit it to the new repository.

### Multi-Language Client Comparison

Generate the same client in several languages (TypeScript, Go, Python, Java) and surface them to platform consumers from a single internal documentation site. The agent loops over the languages returned by `/api/gen/clients` and POSTs the same spec to each, then attaches the download links to the docs page. No authentication is needed, so the loop runs without credential management.

Example prompt: GET `/api/gen/clients` to enumerate languages, then POST the same spec to `/api/gen/clients/typescript-axios`, `/api/gen/clients/go`, and `/api/gen/clients/java-feign`, returning the three fileId values.

### Agent-Driven SDK Scaffolding via Jentic

Wire OpenAPI Generator Online into an AI agent through Jentic so the agent can produce a working client when a developer pastes an API spec. The agent searches Jentic by intent, loads the schema for the relevant generator, and executes - no API key required because the service is open. Setup completes in minutes.

Example prompt: Use Jentic search 'generate a client SDK from an OpenAPI spec', load the `/api/gen/clients/{language}` schema, and execute with language='python' and the user's spec to return a download URL.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/gen/clients` | List supported client SDK languages |
| GET | `/api/gen/clients/{language}` | List options for a client generator |
| POST | `/api/gen/clients/{language}` | Generate a client SDK |
| GET | `/api/gen/servers` | List supported server stub frameworks |
| GET | `/api/gen/servers/{framework}` | List options for a server generator |
| POST | `/api/gen/servers/{framework}` | Generate a server stub |
| GET | `/api/gen/download/{fileId}` | Download a generated archive |

## Key resources

- **Clients** — List supported client SDK languages and submit spec + options to generate a client zip.
- **Servers** — List supported server stub frameworks and submit spec + options to generate a server stub zip.
- **Download** — Download the generated zip archive by fileId after a successful generation.

## Why Jentic

- **Setup:** Wiring the OpenAPI Generator Online API by hand means posting your spec to the right client or server endpoint and handling the generation response yourself. Through Jentic you install once, import the OpenAPI Generator Online API from the API Directory, and your agent calls it with no credential to manage since the service is open.
- **Permission scoping:** OpenAPI Generator Online puts the target language and framework in the URL path (`/api/gen/clients/{language}`), so a rule can pin your agent to specific generation operations over those paths. You choose the operations it may call, so you credit the agent only with the generators you allow.
- **Credential handling:** The OpenAPI Generator Online service requires no credential, so there is nothing to store; any configuration your Jentic One instance holds is kept encrypted and never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'generate a client SDK for a language' or 'list supported server frameworks', and Jentic returns the matching OpenAPI Generator operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Swagger Generator** — SmartBear's hosted code generator producing client SDKs and server stubs from Swagger/OpenAPI specs.
- **SwaggerHub Registry API** — Hosts and versions OpenAPI specs that can be fed into a generator step.
- **GitHub REST API** — Source-control API used to push generated SDK or server stub code into a repository.

## FAQ

### What authentication does the OpenAPI Generator Online API use?

None. The hosted generator is open and accepts unauthenticated POST requests. Through Jentic the call is still routed via the vault execution layer, but no credential is required.

### Can I generate a Python client SDK from an OpenAPI 3 spec?

Yes. POST your spec to `/api/gen/clients/python` (or other Python variants such as python-pydantic-v1) with any required generator options. The response returns a fileId; download the zip from `/api/gen/download/{fileId}` to get the SDK.

### What are the rate limits for the OpenAPI Generator Online API?

The hosted service does not advertise hard rate limits in the spec. The maintainers ask that automation use the API responsibly and self-host the generator JAR for high-volume scenarios. Queue your CI jobs rather than firing in parallel for large fan-outs.

### How do I list all supported languages through Jentic?

Run the Jentic search 'list openapi generator languages', select GET `/api/gen/clients`, and execute with no parameters. The response is the array of language slugs (python, typescript-axios, go, java, etc.) that can then be passed to the generation endpoint.

### Is the OpenAPI Generator Online API free?

Yes, the public hosted instance is free under the Apache 2.0 license of the upstream OpenAPI Generator project. Self-hosting the generator-online docker image is the recommended path when production-grade availability or higher throughput is needed.

### How long is a generated zip available for download?

The fileId returned from a generation request is short-lived; downloads should be performed shortly after generation. For durable artifacts, fetch the zip immediately and store it in your own object storage rather than relying on the hosted cache.

### Can I limit what my agent is allowed to do with the OpenAPI Generator Online API?

Yes. Because you run Jentic One yourself, your own rules decide which of the seven operations the agent may call, and since this API puts the target language and framework in the URL path (for example `/api/gen/clients/{language}` or `/api/gen/servers/{framework}`), you can pin the agent to only the generators you allow. You might let it list generators and download results while blocking the POST generation calls, or restrict it to client generation only and keep server-stub generation off. The service needs no credential, so scoping here is entirely about which operations and paths you permit.