# Kiota and Voxgig, compared

> Microsoft's client generator, built so you do not need a separate SDK per API. MIT, from Microsoft, and pointed at the other side of the API. Kiota is for the team calling somebody else's API, with one shared HTTP stack and fluent request builders across every API you consume. Published by Voxgig, which makes one of the two tools. Facts checked 7 September 2026.

## What it is

Kiota is an MIT-licensed command-line generator from Microsoft. It produces strongly typed, fluent API clients for eight targets, C#, Dart, Go, Java, PHP, Python, Ruby and TypeScript, at varying levels of stability per language. The TypeScript target serves JavaScript too.

It was built for Microsoft Graph, an API with thousands of operations, and almost every design decision follows from that. The generated code is deliberately thin. HTTP, serialization, authentication and middleware live in per-language `kiota-abstractions` packages that you install as dependencies, so the generated client is little more than a typed description of the request surface.

The stated goal, in Microsoft's own words, is to eliminate the need to take a dependency on a different API SDK for every API you call.

That is a different job from the one every other tool on this page does. The rest are bought by the team that owns an API and wants to hand a library to its customers. Kiota is run by the team that has to call twenty other people's APIs and does not want twenty SDKs in its dependency tree.

## Facts

- Made by: Microsoft
- Licence: MIT
- Source: github.com/microsoft/kiota (https://github.com/microsoft/kiota)
- Cost: Free
- Built for: API consumers, at Microsoft Graph scale

## What Kiota does that Voxgig does not

### Shared abstractions instead of a self-contained SDK

One HTTP stack, one serialization layer, one authentication model, one middleware chain, across every API you generate a client for. If you consume fifteen APIs, you configure retry and proxying and telemetry once rather than fifteen times in fifteen vendors' idioms. This is the exact opposite of what Voxgig does, and for the consumer it is clearly the better shape. Voxgig vendors everything into your repository so the generated SDK has no runtime dependency at all, which is what an API provider wants to hand a customer and precisely not what a consumer of fifteen APIs wants to install fifteen copies of.

### Generate a slice of an enormous specification

`--include-path` and `--exclude-path` generate only the operations you actually call. On something the size of Microsoft Graph, generating everything produces a client no compiler is pleased to see and no human wants to read. Kiota is the only tool here that treats the specification is enormous as the normal case rather than the edge case, and if your team calls four endpoints of a thousand-endpoint API, nothing else on this page handles that as gracefully.

### Fluent request builders that mirror the URL

`client.Users["id"].Messages.Get()` reads like the path it calls. The point is predictability across APIs: once you know the shape, every Kiota client works the same way regardless of who wrote the specification. Voxgig makes the opposite bet, that entities and operations are a better level to work at than paths, which is why its CLI is `myapi load myentity` rather than a URL. Both are defensible. They suit different readers.

### A large vendor pays for it, and you are still not locked in

MIT, on GitHub, maintained by Microsoft with the .NET and Graph ecosystems behind it. That combination is rare, and it is a serious answer to the longevity question that this field has had a bad year on.

## Side by side

| | Kiota | Voxgig |
| --- | --- | --- |
| Whose problem it solves | The team calling an API | The team that owns the API |
| Licence | MIT | MIT |
| Cost | Free | Free |
| Language targets | 8, at varying maturity | 22 bundled language targets, more from packages |
| Generated code | Thin, over installed `kiota-abstractions` packages | Self-contained, no runtime dependency |
| Cross-cutting behaviour | Middleware in the shared abstractions, per language | 18 generated features, same options in every target |
| Partial generation | Yes, by path include and exclude | Whole model |
| MCP server, CLI, REPL | No | Yes |

## Choose Kiota when

- You are consuming somebody else's API and you want one client style and one HTTP stack across all of them.
- The specification is enormous and you need a slice of it.
- You are in .NET and want the ecosystem's own tool, maintained by the same company as the runtime.
- You would rather configure retry and telemetry once in middleware than have it generated into each client.

## Choose Voxgig when

- You are the API provider and your customers will judge the library by how it reads and what it needs installed.
- You want a self-contained SDK with no runtime dependency, because every dependency you add is one your customers' security teams will ask about.
- You want retries, caching, idempotency, cost tracking and tracing as generated features with identical options in every language, rather than middleware each consumer assembles.
- You need the MCP server, CLI, REPL or Agent Skills surfaces.

## Limits of this comparison

- These two tools are not substitutes. Kiota is included because it is commonly shortlisted alongside the others, and that shortlist usually resolves on one question: whether you are consuming an API or publishing one.
- Language maturity varies a lot across Kiota's targets. Check the support matrix for yours rather than trusting a count.
- If you consume many APIs and also publish one, using both tools is a sensible answer and not a contradiction.

Corrections go to info@voxgig.com. A correction changes the page and moves its checked date.

## First-party sources

- [Kiota documentation](https://learn.microsoft.com/openapi/kiota/)
- [Kiota on GitHub](https://github.com/microsoft/kiota)

## The other comparisons

- [All SDK generator comparisons](https://voxgig.com/sdk/comparisons): the index, the method, and the wider field.
- [OpenAPI Generator](https://voxgig.com/sdk/comparisons/openapi-generator): The community generator most APIs have shipped an SDK from at least once.
- [Speakeasy](https://voxgig.com/sdk/comparisons/speakeasy): Commercial SDK generation with the widest non-SDK output in this comparison.
- [Fern](https://voxgig.com/sdk/comparisons/fern): SDKs and a documentation site from one definition. Part of Postman since January 2026.
- [Stainless](https://voxgig.com/sdk/comparisons/stainless): The generator behind many of the best-known AI SDKs. Its hosted product is winding down.
- [APIMatic](https://voxgig.com/sdk/comparisons/apimatic): The longest-running commercial generator here, and the only one that converts between description formats.
- [liblab](https://voxgig.com/sdk/comparisons/liblab): SDK generation shaped as a release pipeline. Part of Postman since November 2025.
- [Hey API](https://voxgig.com/sdk/comparisons/hey-api): The TypeScript ecosystem's generator. One language, done properly.
- [Voxgig SDK Generator](https://voxgig.com/sdk)