OpenAPI Specification
The OpenAPI Specification is a standard format for describing an HTTP API. It records endpoints, inputs, outputs, and authentication so people and software tools can understand the API without reading its implementation.
itSoftware engineering | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: OpenAPI Specification
An OpenAPI Description is a written account of an HTTP API that software can read. It says which requests a service accepts and which responses it claims to return. The OpenAPI Specification defines how to write that account. It does not serve requests, inspect a running service, or persuade a missing endpoint to appear.
Before a shared description, an API consumer often had to assemble a picture from prose, examples, client code, and trial requests. A description puts the endpoint map, inputs, outputs, and access declarations in one inspectable format. Documentation tools can render it. Code generators can consume it. A reviewer can ask whether the contract matches the service. The last job still needs evidence from the service itself, which is mildly inconvenient but preferable to trusting a drawing of a bridge.
Three ideas hold the document together. First, the root openapi value identifies the OAS feature set a tool must understand; info.version is the publisher's version of the API contract. Similar-looking version fields, different jobs. Second, servers, paths, and HTTP methods lead you to an operation. Its parameters and request body describe inputs; its responses describe outcomes. Third, components hold reusable definitions, and references connect those definitions to operations. A neat document with a broken reference is less helpful than a messy document that resolves.
The surprise is that a valid description is not proof of a correct implementation. A validator can tell you that the document has acceptable structure. It cannot tell you that the deployed service returns the documented status code or JSON shape. For that, compare real or test responses with the contract. A generated client can be consistent with a document and still disagree with the server. Everyone has followed the instructions, except perhaps the system that matters.
Security has a similar trap. A security scheme names a mechanism, such as an API key or bearer token. A security requirement applies a scheme to the API or an operation. Merely listing a scheme does not declare which operation needs it, and neither field enforces authorization. The server has that job.
Read the Intro for the complete map, then the Slides when the relationships need to fit on one screen. Use the Cheatsheet to trace an operation, and the Practice Reference to inspect a real description. The Reference links lead to the official definitions when a field or version rule needs a precise answer.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://spec.openapis.org/oas/latest.html
Supports
- OAS document structure, objects, fields, examples, security, and version semantics
- Specification revision history and 3.2 features
- External reference security and schema authority
- https://spec.openapis.org/oas/
Supports
- Published versions and informational schema iterations
- Authoritative specification text when a schema disagrees
- https://learn.openapis.org/specification/
Supports
- Official learning path and introductory explanation
- https://learn.openapis.org/specification/structure.html
Supports
- Root requirements and linked description structure
- https://learn.openapis.org/specification/paths.html
Supports
- Paths, operations, parameters, and responses
- https://learn.openapis.org/specification/components.html
Supports
- Reusable components and references
- https://learn.openapis.org/specification/security.html
Supports
- Security schemes and applied security requirements
- https://github.com/OAI/OpenAPI-Specification/releases
Supports
- Published release information and repository provenance
- https://github.com/OAI/OpenAPI-Specification/blob/main/CONTRIBUTING.md
Supports
- Community-driven minor and patch release process
- https://www.openapis.org/blog/2025/09/23/announcing-openapi-v3-2
Supports
- OpenAPI 3.2 streaming and tag changes
- https://github.com/sindresorhus/awesome
Supports
- Discovery index for curated technology lists
- https://github.com/APIs-guru/awesome-openapi3
Supports
- Curated OpenAPI tool discovery
- https://github.com/APIs-guru/awesome-openapi3/blob/master/docs/_data/tools.yaml
Supports
- Redocly, OpenAPI Generator, openapi-diff, Swagger Editor, and OpenAPI GUI listings
- https://redocly.com/docs/cli
Supports
- Redocly CLI linting, bundling, and documentation uses
- https://openapi-generator.tech/
Supports
- OpenAPI Generator client and server generation
- https://github.com/OpenAPITools/openapi-diff
Supports
- Comparison of OpenAPI descriptions
- https://swagger.io/open-source/
Supports
- Swagger Editor editing and rendering features
- https://swagger.io/blog/whats-new-in-swaggerhub-openapi-3-1/
Supports
- SwaggerHub shared catalog and editing use
- https://mermade.github.io/openapi-gui/
Supports
- Visual OpenAPI editing fields and interface
- https://info.42crunch.com/hubfs/datasheet/api-security-platform.pdf
Supports
- OpenAPI security audit role of 42Crunch
- https://swagger.io/blog/testing-at-ai-speed-we-built-a-drift-detection-capability-then-used-it-on-ourselves/
Supports
- Published practitioner account of OpenAPI document and runtime drift
- https://github.com/Redocly/redocly-cli/issues/2964
Supports
- Reproduced bundling loss of OpenAPI 3.1 schema reference siblings
