# Typed API client

> AI-ranked search results for `strongly typed client interfaces` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 115 total matches; showing the top 16.

Explore on the web: https://awesome-repositories.com/q/strongly-typed-client-interfaces

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/strongly-typed-client-interfaces).**

## Results

- [azure/autorest](https://awesome-repositories.com/repository/azure-autorest.md) (4,798 ⭐) — AutoRest is a multi-language SDK generator and OpenAPI code generator designed to produce consistent software development kits from a single API definition. It functions as a REST API client generator that transforms Swagger and OpenAPI specification files into functional, typed HTTP client libraries.

The tool automates the SDK development workflow by converting design documents into source code, ensuring that the resulting implementations match the defined API contract across different programming languages.

The system employs specification-driven development using an intermediate represent
- [acacode/swagger-typescript-api](https://awesome-repositories.com/repository/acacode-swagger-typescript-api.md) (4,093 ⭐) — swagger-typescript-api is a utility that parses OpenAPI definitions to generate strongly typed data models and service wrappers for web applications. It transforms OpenAPI specifications into type-safe TypeScript API clients, removing the need for manual request and response boilerplate.

The generator produces interchangeable client logic via pluggable transport adapters, allowing users to switch between Fetch and Axios for network requests. It uses template-based source emission to inject generated types and methods into a consistent client structure.

The project handles the mapping of Open
- [astahmer/openapi-zod-client](https://awesome-repositories.com/repository/astahmer-openapi-zod-client.md) (1,172 ⭐) — This project is a command-line tool that automates the creation of type-safe TypeScript HTTP clients directly from OpenAPI specifications. By transforming service definitions into structured source code, it ensures end-to-end type synchronization and enforces runtime data integrity across network boundaries.

The generator distinguishes itself by mapping OpenAPI data structures into Zod validation schemas, allowing for consistent schema-driven type mapping and response validation. It supports deduplicated source synthesis to minimize redundancy in the generated output and provides template cus
- [hey-api/openapi-ts](https://awesome-repositories.com/repository/hey-api-openapi-ts.md) (4,128 ⭐) — openapi-ts is a tool and orchestrator used to convert OpenAPI specifications into type-safe TypeScript SDKs and HTTP client implementations. It automatically generates typed interfaces and request functions from API definitions to ensure consistency between the server and the client.

The project employs a transport-agnostic client interface, decoupling high-level API calls from the underlying network library. It uses a plugin-based generation pipeline and a custom plugin architecture to allow for the customization of output types and validation schemas.

The system provides capabilities for n
- [orval-labs/orval](https://awesome-repositories.com/repository/orval-labs-orval.md) (6,145 ⭐) — Orval is an OpenAPI-to-TypeScript code generator that produces fully typed API clients, data-fetching hooks, mock data, validation schemas, and server handlers from OpenAPI or Swagger specifications. It reads any YAML or JSON API specification and generates TypeScript interfaces, HTTP request functions, and framework-specific integration code that ensures compile-time correctness for all API calls.

The project distinguishes itself by generating production-ready data-fetching hooks for React Query, Vue Query, Svelte Query, Solid Query, Angular, and SWR, complete with automatic cache invalidati
- [ts-rest/ts-rest](https://awesome-repositories.com/repository/ts-rest-ts-rest.md) (3,262 ⭐) — ts-rest is a TypeScript toolkit for building type-safe APIs by defining a shared contract that connects client and server code. The core idea is to specify endpoints, methods, request and response shapes in a single contract, then use that contract to generate fully typed clients and enforce server implementations that match the contract at compile time.

The project provides a way to consume remote APIs through a client that infers request and response shapes from the shared contract, offering autocompletion and compile-time checks. On the server side, it enforces that handlers return correct
- [middleapi/orpc](https://awesome-repositories.com/repository/middleapi-orpc.md) (4,862 ⭐) — orpc is a contract-first API development framework for TypeScript that starts with a shared contract definition and generates type-safe clients and servers from that single source of truth. It guarantees end-to-end type safety, meaning inputs, outputs, errors, and streaming data are all checked at compile time across the client–server boundary.

What distinguishes orpc from typical RPC frameworks is its ability to export contracts as OpenAPI specifications, to optimize server-side rendering by calling API handlers directly inside the server process, and to support real‑time bidirectional commu
- [openapitools/openapi-generator-cli](https://awesome-repositories.com/repository/openapitools-openapi-generator-cli.md) (1,956 ⭐) — OpenAPI Generator CLI is a command-line utility designed to automate the creation of API artifacts from specification files. It functions as a tool for generating client libraries, server stubs, and documentation, enabling developers to produce consistent boilerplate code and reference materials across various programming languages.

The project provides a wrapper that manages the lifecycle of a Java-based execution engine, which performs the actual code synthesis using logic-less templates. To ensure reproducible results and avoid dependency conflicts on the host system, the tool supports ver
- [microsoft/kiota](https://awesome-repositories.com/repository/microsoft-kiota.md) (3,777 ⭐) — Kiota is a multi-language SDK generator and REST API client orchestrator that transforms OpenAPI descriptions into strongly typed client libraries. It provides a framework for managing API specifications and generating typed interfaces to eliminate manual boilerplate development.

The project utilizes a template-driven source emission system to map API specifications to native language types. It ensures consistency across environments using lock-file version syncing and organizes API endpoints into a nested object structure based on the hierarchical mapping of URI paths.

The toolset includes
- [fern-api/fern](https://awesome-repositories.com/repository/fern-api-fern.md) (3,680 ⭐) — Fern is a toolset for managing API specifications, generating type-safe client libraries, and producing hosted developer documentation. It provides a utility for validating, transforming, and exporting API definitions into standardized OpenAPI formats, serving as a system to maintain a consistent source of truth for API designs.

The project differentiates itself through an automated SDK distribution pipeline that publishes generated libraries to package managers such as npm, PyPI, Maven, and NuGet. It also includes an AI-powered search assistant trained on API and SDK specifications to answer
- [go-swagger/go-swagger](https://awesome-repositories.com/repository/go-swagger-go-swagger.md) (9,989 ⭐) — go-swagger is a toolkit for working with Swagger/OpenAPI 2.0 specifications in Go. It generates server, client, and CLI code from a specification document, and can also produce a specification by scanning annotated Go source code. The project includes a static validation engine that checks documents against the schema and project-specific rules, and a specification transformation pipeline that resolves, flattens, and merges documents.

The toolkit generates both client and server code from the same specification, ensuring consistency in request and response handling. It also produces a command
- [trpc/trpc](https://awesome-repositories.com/repository/trpc-trpc.md) (40,348 ⭐) — This project is an end-to-end type-safe API framework designed to synchronize data structures between frontend and backend codebases without the need for manual code generation. By leveraging TypeScript’s type inference, it allows developers to invoke server-side functions directly from the client as if they were local methods. This remote procedure call approach abstracts away the complexities of HTTP verbs and URL structures, streamlining the full-stack development workflow into a unified experience.

The framework distinguishes itself through a modular router architecture that organizes bac
- [openapitools/openapi-generator](https://awesome-repositories.com/repository/openapitools-openapi-generator.md) (26,412 ⭐) — This project is a command-line tool and template-based scaffolding engine that transforms API interface specifications into functional client libraries and server stubs. By automating the creation of type-safe SDKs and boilerplate code, it bridges the gap between service definitions and implementation, allowing developers to maintain synchronized codebases across many programming languages.

The tool distinguishes itself through a portable execution model that utilizes containerized build isolation to ensure identical output regardless of the host environment. It features a modular, plugin-bas
- [swagger-api/swagger-codegen](https://awesome-repositories.com/repository/swagger-api-swagger-codegen.md) (17,760 ⭐) — Swagger Codegen is a template-driven engine and multi-language toolkit used to generate API client SDKs, server stubs, and human-readable documentation from OpenAPI specifications. It translates these specifications into functional libraries and boilerplate routing code across various target programming languages.

The tool utilizes a pluggable generator module system and an integrated template engine, allowing for the customization of generated source code and the creation of new language-specific generators. It supports flexible specification sourcing via local files, remote HTTP endpoints,
- [vojtechhabarta/typescript-generator](https://awesome-repositories.com/repository/vojtechhabarta-typescript-generator.md) (1,216 ⭐) — TypeScript generator is a build tool that parses backend class structures and REST endpoints in Java to generate corresponding TypeScript types and client services. It functions as both a static type definition generator and a Java REST client generator, translating compiled class properties, collections, and server-side endpoint definitions into equivalent frontend type definitions and client-side service classes.

The tool builds an abstract syntax representation from scanned bytecode using reflection and compiles output through configurable module scoping, formatting declarations into globa
- [ferdikoomen/openapi-typescript-codegen](https://awesome-repositories.com/repository/ferdikoomen-openapi-typescript-codegen.md) (3,369 ⭐) — Openapi-typescript-codegen is a code generation tool that parses OpenAPI specification files, URLs, or strings to build type-safe TypeScript or JavaScript network clients. It transforms raw API definitions into structured internal abstract syntax trees before mapping them onto custom text templates.

The tool provides a pluggable network layer that supports interchangeable transport libraries such as Fetch or Axios. It normalizes diverse endpoint structures into a unified internal schema to generate strongly typed client source code.

Execution occurs synchronously through command line argumen