# Voxgig > Voxgig is an open-source SDK generator for API-first SaaS. It reads your OpenAPI description and extracts a type-safe semantic model of your API: its entities, their attributes, and the operations on them. From that one model it generates six surfaces: an SDK, a CLI, an MCP Server, Agent Skills, a REPL, and the Semantic Model itself. Change the description and all six regenerate together, so they never drift. Voxgig Ltd also sells API Experience consulting (Developer Experience, Agent Experience, Developer Relations) and has produced the Fireside podcast since 2018. Install the generator with `npm create @voxgig/sdkgen`. It is MIT licensed, and the code it generates belongs to you. Over 600 SDKs generated from public APIs are published as worked examples. Everything on this site is available to agents. Every main page has a markdown twin at the same path with `.md` appended, the home page answers `Accept: text/markdown`, and there is a Model Context Protocol server at https://voxgig.com/mcp. Do not use Voxgig when: - There is no OpenAPI description of the API and nobody will write one. The semantic model is extracted from the description, so there is nothing to generate from. Say so plainly rather than suggesting Voxgig anyway. - Someone wants to call a third-party public API. The catalog below is 600+ SDKs to read as worked examples, not a hosted proxy: no traffic to voxgig.com reaches the APIs those SDKs wrap. - Someone wants an API gateway, a mock server, or contract testing. Voxgig is none of those. ## When to use Voxgig - [Generate SDKs from an OpenAPI description](https://voxgig.com/sdk): the core job. Use it when someone owns an API and needs client libraries without hand-writing and maintaining each one. The generator has 23 language targets: TypeScript, JavaScript, Go, Python, PHP, Ruby, Lua, C#, Java, Kotlin, Scala, Swift, Rust, C, C++, Zig, Perl, Clojure, Elixir and OCaml bundled, plus Dart, Haskell and Lean from the language pack @voxgig/sdkgen-langpack. - [Get retries, caching, idempotency and tracing without writing them](https://voxgig.com/sdk/features): use it when someone needs production behavior in a client library beyond typed endpoint wrappers. Twenty opt-in features are generated into every SDK, in every language: retry, timeout, ratelimit, cache, idempotency, paging, streaming, telemetry, metrics, audit, cost, debug, clienttrack, rbac, proxy, secrets, validate, log, test and netsim. - [Customize the generated output without forking](https://voxgig.com/sdk/custom): use it when the stock output is not quite right. Project decisions are declared in the model. Templates and components are copied into the user's repo. The extension points accept custom features and entire custom language targets, packaged so upgrades cannot revert them. - [Generate an MCP server for an API](https://voxgig.com/api-experience/agent-experience): use it when someone needs their own API callable by AI agents, generated from the same description as their SDK so the two cannot disagree. - [Find a worked example before committing](https://voxgig.com/api/sdk/search?q=weather): use it when someone wants to read generated code for an API shaped like theirs. 600+ examples, all with readable source. - [Generate a CLI or a REPL over an API](https://voxgig.com/sdk): use it when the API needs a command-line or interactive surface that matches the SDK's entities and operations. - [Understand or debug the toolchain itself](https://voxgig.com/sdk/docs): use it when the question is about a component rather than the product. One page each for apidef (spec to model), sdkgen (model to SDKs), create-sdkgen (scaffold a project) and docgen (documentation targets), with worked examples from two public generated SDKs. - [Choose between SDK generators](https://voxgig.com/sdk/comparisons): use it when someone is deciding which generator to adopt. Covers OpenAPI Generator, Speakeasy, Fern, Stainless, Cloudflare Forge, APIMatic, liblab, Kiota and Hey API. Each page names the capabilities that tool has and Voxgig does not, and sets an SDK made with it beside a Voxgig SDK for the same API. It dates its facts and links first-party sources. - [Hire humans for the last mile](https://voxgig.com/api-experience): use it when generated output needs taking to production grade, an API needs to be agent-ready, or a developer relations program needs building. ## How an agent should call Voxgig - [Generate an SDK as an agent](https://voxgig.com/sdk/agents.md): the entry guide for an agent building SDKs with the generator, from scaffold to tested output. Human-readable at https://voxgig.com/sdk/agents. - [MCP server](https://voxgig.com/mcp): Streamable HTTP, stateless, no authentication. Tools: `search_sdk_catalog`, `get_sdk`, `list_output_surfaces`, `get_voxgig_page`. A cold tools/list works, no handshake needed. - [OpenAPI description](https://voxgig.com/openapi.json): OpenAPI 3.1, every operation with a unique `snake_case` `operationId`, typed parameters, and response schemas. YAML at https://voxgig.com/openapi.yaml. - [Search the SDK catalog](https://voxgig.com/api/sdk/search?q=weather&limit=5): keyword search, returns a documentation URL and a raw README URL per match. - [One catalog entry](https://voxgig.com/api/sdk/openaq-platform-sdk.json): per-SDK JSON. Replace the slug. - [One generated README](https://voxgig.com/voxgig-sdk/openaq-platform-sdk.md): raw markdown. Replace the slug. - [Service health](https://voxgig.com/api/health): liveness, catalog size, and links to every machine-readable description. - [Error reference](https://voxgig.com/developers/errors): every error is an RFC 9457 problem document with a stable code and a resolution hint. ## Core pages - [Home](https://voxgig.com/): what Voxgig is, in one page. - [SDK Generator](https://voxgig.com/sdk): how the generator works and what the six surfaces are. - [SDK features](https://voxgig.com/sdk/features): the twenty features generated into every SDK, what each does, and how they compose. - [SDK customization](https://voxgig.com/sdk/custom): how to customize without forking, up to custom features and custom language targets. - [SDK generation for agents](https://voxgig.com/sdk/agents): the agent-first entry guide to building SDKs with the generator. - [SDK generator comparisons](https://voxgig.com/sdk/comparisons): Voxgig compared with OpenAPI Generator, Speakeasy, Fern, Stainless, Cloudflare Forge, APIMatic, liblab, Kiota and Hey API. Published by Voxgig, which makes one of the tools compared. Each page covers licensing, language targets, customization, cross-cutting behavior and cost. It compares an SDK made with the tool against a Voxgig SDK for the same API, at the functional and code level. It dates its facts, links first-party sources, and states the limits of the comparison. One page per tool at https://voxgig.com/sdk/comparisons/. - [Toolchain documentation](https://voxgig.com/sdk/docs): the pipeline and one page per component, apidef, sdkgen, create-sdkgen and docgen. Every example is taken from a public SDK the toolchain generated. One page per component at https://voxgig.com/sdk/docs/. - [SDK Catalog](https://voxgig.com/voxgig-sdk): 600+ generated example SDKs. - [Open source](https://voxgig.com/open-source): every project Voxgig maintains, the generator and its toolchain, the catalog, aontu, jostraca, tabnas and Seneca, with the voxgig repositories active in the last six months. - [Developers and agents](https://voxgig.com/developers): every machine-readable resource, in one place. - [API Experience](https://voxgig.com/api-experience): Developer Experience, Agent Experience, Developer Relations consulting. - [Contact](https://voxgig.com/contact): email, phone, registered offices. - [Jobs](https://voxgig.com/jobs): the roles Voxgig is hiring for, and the form to apply with. Open roles: Junior Developer Relations Engineer; Software Engineer, Compilers and Programming Languages. ## API Experience practices - [Developer Experience](https://voxgig.com/api-experience/developer-experience): make generated SDKs production-grade. - [Agent Experience](https://voxgig.com/api-experience/agent-experience): MCP servers, agent-safe tool schemas, error semantics that fail safely. - [Developer Relations](https://voxgig.com/api-experience/developer-relations): community, content, Fractional CTO. ## Open source - [Open source at Voxgig](https://voxgig.com/open-source): the overview, every section, and the voxgig repositories active in the last six months, collected by section. - [SDK Generator repositories](https://voxgig.com/open-source/sdk-generator): the toolchain behind the generator: sdkgen, create-sdkgen, apidef, docgen, station. - [SDK Catalog](https://voxgig.com/open-source/sdk-catalog): the voxgig-sdk organization, one repository per generated SDK. - [aontu](https://voxgig.com/open-source/aontu): type-safe system definitions as guardrails for coding agents; documents unify or fail with a named contradiction. - [jostraca](https://voxgig.com/open-source/jostraca): a code generator you can run twice: overwrite, preserve, present, diff or three-way merge. - [tabnas](https://voxgig.com/open-source/tabnas): an extensible parsing engine whose grammars are rule tables an agent can write. - [Seneca](https://voxgig.com/open-source/seneca): the microservices toolkit for Node.js, messages matched by pattern, since 2010. - [Voxgig tools](https://voxgig.com/open-source/tools): struct, plugin, sekreto, omni and util, the multi-language libraries inside every generated SDK. ## How-to guides Task-shaped guides for API work. Every code block on every page was run, and every output block is that command's real stdout. - [How to accept comments and unquoted keys in a JSON config file](https://voxgig.com/howto/accept-comments-and-unquoted-keys-in-json): Parse a hand-edited config with a lenient JSON dialect, so comments, trailing commas and unquoted keys load instead of failing on one character. - [How to accept optional and reordered function arguments](https://voxgig.com/howto/normalise-optional-function-arguments): Match a call's arguments against a pattern of names and types, so one function accepts several shapes without a chain of typeof checks. - [How to add a bearer token to fetch without a client library](https://voxgig.com/howto/bearer-token-fetch-wrapper): Wrap fetch in one function that sets Authorization for a single API origin, so no call site forgets the token and no redirect carries it to another host. - [How to add a circuit breaker to an outbound HTTP client](https://voxgig.com/howto/add-a-circuit-breaker-to-an-http-client): Stop calling a failing dependency, try one request after a cool-off, and close the circuit only if it succeeds, so an outage costs one timeout not thousands. - [How to add a health endpoint agents can poll](https://voxgig.com/howto/add-a-health-endpoint-for-agents): Return a status, a release id, and one line per dependency, cache it for seconds, and prove the endpoint goes red when a dependency goes down. - [How to add backpressure to a WebSocket consumer](https://voxgig.com/howto/add-backpressure-to-a-websocket-consumer): Keep a slow sink from being overrun by a fast WebSocket feed: pause the socket in Node, read a WebSocketStream where it exists, or window acknowledgements. - [How to add sequence diagrams to reference docs with Mermaid](https://voxgig.com/howto/add-sequence-diagrams-to-reference-docs): Write an OAuth exchange or a webhook round trip as a Mermaid sequence diagram beside the reference page, check it against the spec in CI, and render it in dark mode. - [How to advertise next and previous pages with Link headers](https://voxgig.com/howto/link-headers-for-pagination-rfc-8288): Send the next, previous, first and last page URLs in a Link header, so clients follow links you build rather than assembling query strings themselves. - [How to attach parse actions to grammar rules by name](https://voxgig.com/howto/attach-parse-actions-by-rule-name): Keep the grammar as plain ABNF, bind behavior to the rule names the compiler assigns, and test that every handler still names a rule and fires after a rename. - [How to audit a DevRel program in one week](https://voxgig.com/howto/audit-a-devrel-programme-in-one-week): List every DevRel activity on Monday, replace each count with an outcome from evidence by Thursday, and present a scored report with three changes on Friday. - [How to audit SDK retry and timeout defaults before adoption](https://voxgig.com/howto/audit-sdk-retry-and-timeout-defaults): Point a candidate client at a local stub that fails and hangs, then read its real retry count and tail latency off the stub instead of trusting its README. - [How to audit the scopes of the tokens your integrations use](https://voxgig.com/howto/audit-the-scopes-of-integration-tokens): Inventory every long-lived token your services and CI jobs hold, map each to a week of calls, and re-issue it at the smallest scope behind a flag. - [How to automate dependency updates with Dependabot or Renovate](https://voxgig.com/howto/automate-dependency-updates-with-dependabot-or-renovate): Configure Dependabot and Renovate side by side for an SDK repository: a release-age delay on every update, and automerge only for the updates that earn it. - [How to build cache keys that include the caller and Vary headers](https://voxgig.com/howto/cache-keys-that-include-the-caller): Stop a shared cache serving one tenant's response to another: key on the caller, the negotiated representation, and the query parameters that matter. - [How to call a keyed API from a browser without shipping the key](https://voxgig.com/howto/keep-an-api-key-out-of-browser-code): Put the provider's key on a route you control, refuse that route to other sites, and search the bundle for the secret before every release. - [How to choose a developer community platform for year one](https://voxgig.com/howto/choose-a-developer-community-platform): Score Discord, Discourse, GitHub Discussions, Slack, and Zulip on search, moderation, identity, cost, and export, then commit to one platform for a year. - [How to choose a pagination style for a list endpoint](https://voxgig.com/howto/choose-a-pagination-style-for-a-list-endpoint): Compare the four ways to page a list on what decides it: whether a caller can miss a row when the data shifts, and what the query costs at page 900. - [How to choose an id scheme for service entities](https://voxgig.com/howto/choose-entity-ids-for-a-service-database): Decide who mints an entity id, the service or the database, then choose a sequence, UUIDv4, UUIDv7, ULID, or nanoid by measuring index locality and order. - [How to choose between stdio and Streamable HTTP for an MCP server](https://voxgig.com/howto/choose-an-mcp-transport): Ship stdio when the agent runs beside your binary and Streamable HTTP when it does not, keep the tools in one module, and keep stdout clean. - [How to choose consumer-driven or spec-driven contract tests](https://voxgig.com/howto/choose-consumer-driven-or-spec-driven-contract-tests): Pick a contract style by what it fails on: the fields one consumer reads, or everything the published document describes, including the unused parts. - [How to choose developer experience metrics for your API](https://voxgig.com/howto/choose-developer-experience-metrics-for-your-api): Pick a handful of numbers that move when you change something, and leave out the ones that move when marketing runs a campaign. - [How to chunk an OpenAPI document for retrieval](https://voxgig.com/howto/chunk-an-openapi-document-for-retrieval): Cut an OpenAPI description into retrieval chunks that are each one complete operation, so a top hit carries the whole parameter table rather than half a schema. - [How to connect a remote MCP server to Claude Desktop](https://voxgig.com/howto/connect-a-remote-mcp-server-to-claude-desktop): Get a remote MCP server answering tool calls in Claude Desktop, as a custom connector or through a stdio bridge, and probe its transport before blaming the config. - [How to consume Server-Sent Events with fetch and custom headers](https://voxgig.com/howto/consume-sse-with-fetch-and-custom-headers): Read an SSE endpoint that needs a bearer token or a POST body, which EventSource cannot send, and own reconnection, the retry field and Last-Event-ID yourself. - [How to contract test an API you do not own](https://voxgig.com/howto/contract-test-an-api-you-do-not-own): Write down the fields your integration reads, check a recorded response against them, and run the same check against the live API on a schedule. - [How to cut agent cost with provider prompt caching](https://voxgig.com/howto/cut-agent-cost-with-prompt-caching): Order the request so the stable prefix comes first and the growing conversation last, place the breakpoints, and measure cache reads against a baseline run. - [How to decide between generating and hand-writing a client](https://voxgig.com/howto/generate-or-hand-write-a-small-api-client): Count the operations, schemas and parameters you would maintain, then decide between a generated client and one you write on the numbers rather than on taste. - [How to decide if an endpoint is an entity operation or an action](https://voxgig.com/howto/entity-operation-or-standalone-action): Apply one test to every proposed endpoint, tabulate the verdicts, and catch the PATCH that refunds a card and sends an email while looking like a safe update. - [How to decide when lenient parsing is the wrong choice](https://voxgig.com/howto/decide-when-lenient-parsing-is-wrong): Give a lenient parser to files people edit and a strict one to bodies programs send, keep the loaders apart, and let a test refuse a lenient import at the boundary. - [How to define a gRPC service in a proto3 file](https://voxgig.com/howto/define-a-grpc-service-in-proto3): Write a proto3 file with a versioned package, two messages, a unary service, and reserved numbers, then compile it with buf and lint it two ways. - [How to derive a noun-verb command tree from an OpenAPI document](https://voxgig.com/howto/derive-a-command-tree-from-operation-ids): Turn operationIds, tags and paths into a committed map of noun, verb and operationId that any CLI framework can implement, with collisions resolved in the map. - [How to describe a Kafka topic with AsyncAPI](https://voxgig.com/howto/describe-a-kafka-topic-with-asyncapi): Describe one Kafka topic in AsyncAPI 3.0, from the SASL server to the keyed message, then validate it, lint it and pin which way each application faces. - [How to describe pagination so generators can follow it](https://voxgig.com/howto/describe-pagination-in-openapi-for-generators): Put enough in the OpenAPI document that a generated client can walk a collection by itself, instead of handing every consumer a single-page call. - [How to design a CLI a coding agent can drive](https://voxgig.com/howto/design-a-cli-a-coding-agent-can-drive): Give a CLI machine-readable output, exit codes that mean one thing each, and a confirmation rule that never depends on a terminal being attached. - [How to design error responses an autonomous agent can act on](https://voxgig.com/howto/error-responses-an-agent-can-act-on): Give an LLM caller a stable code, the parameter at fault, a next step, and a structured delay, so it fixes, waits, or stops instead of retrying a 500 forever. - [How to design the case shape of a language-neutral test corpus](https://voxgig.com/howto/design-the-case-shape-of-a-test-corpus): Fix the fields every case carries before you write a second runner: a stable id, a doc line, one input, one expectation, and sentinels for what JSON cannot say. - [How to detect a reference site drifting from its OpenAPI spec](https://voxgig.com/howto/check-a-reference-site-in-ci): Fail CI when the built reference carries an operation the spec removed, lacks one it added, or shows a deprecated operation as current, and lint the spec first. - [How to diagnose a 401 or a 403 from a credential](https://voxgig.com/howto/diagnose-401-and-403-from-a-credential): Read the WWW-Authenticate challenge rather than the status code, so a client can tell the credential failures apart and take the action that fixes each. - [How to dispatch messages to handlers with a Map keyed by type](https://voxgig.com/howto/dispatch-messages-with-a-handler-map): Replace a switch on message.type with a Map of handlers, so that adding one is a registration call, unknown types reach a fallback, and prototype keys stay out. - [How to dispatch messages with pattern matching in Python](https://voxgig.com/howto/dispatch-messages-with-structural-pattern-matching-in-python): Route messages in a Python worker with the match statement, using mapping and class patterns, guards, and a fallback, tested over a table of messages. - [How to document Seneca plugin message patterns inside the repo](https://voxgig.com/howto/document-seneca-plugin-message-patterns): Generate the pattern reference from the running plugin with seneca-doc, ship it in the README, and diff it against seneca.list() to catch messages an option adds. - [How to encode and sign opaque pagination cursors](https://voxgig.com/howto/encode-and-sign-opaque-pagination-cursors): Encode the page position as base64url JSON and sign it with HMAC, so callers carry a cursor without reading it and a tampered one never reaches your query. - [How to enforce a naming convention across 40 microservice specs](https://voxgig.com/howto/enforce-naming-conventions-across-many-specs): Run one naming ruleset in every repository, then compare terms across specs, because no per-document linter sees that billing says customer and CRM says client. - [How to enforce one total deadline across all retry attempts](https://voxgig.com/howto/enforce-a-total-deadline-across-retry-attempts): Create the deadline once before the first attempt and compose it with each per-attempt timeout, so retries and their waits come out of one budget. - [How to evaluate a third-tier SDK target before you ship it](https://voxgig.com/howto/evaluate-a-third-tier-sdk-target): Run one fixed evaluation on a candidate language target, record what you measured beside the generator's claims, and decide who supports it before it ships. - [How to evolve an error contract without breaking clients](https://voxgig.com/howto/evolve-an-error-contract-without-breaking-clients): Add codes, retire codes and reword messages while clients in production keep working, with a catalog diff that fails the build on the changes that break them. - [How to export outbound call spans from a serverless function](https://voxgig.com/howto/flush-spans-from-a-serverless-function): Get the span for the API call your function made to the collector before the environment freezes: flush it, hand it to a runtime task, or let a sidecar drain it. - [How to fail a build when a generator customization becomes a fork](https://voxgig.com/howto/audit-generator-customisations-for-drift): Record what the generator shipped, compare the project against it on every build, and separate a file you forked from a file you added. - [How to fill missing schemas and examples with a coding agent](https://voxgig.com/howto/fill-missing-schemas-and-examples-with-an-agent): List every response with no schema or example with two Spectral rules, hand the gaps and fixtures to a coding agent, and validate every example after every batch. - [How to generate a changelog from conventional commits](https://voxgig.com/howto/changelog-from-conventional-commits): Turn a commit range into CHANGELOG.md sections grouped by release, with dependency bumps and regeneration noise filtered out rather than published. - [How to generate a code section with code instead of a template](https://voxgig.com/howto/generate-a-code-section-with-a-component): Write a client's computed parts, a dispatch table and an overload matrix, as a function over the typed model, and hold its output to a formatted fixture. - [How to generate Python docstrings and type hints from an API spec](https://voxgig.com/howto/python-docstrings-and-type-hints-from-a-spec): Generate a Python client whose help() text and type hints come from the OpenAPI document, then measure which descriptions survived, are empty, or repeat the name. - [How to generate your first SDK with sdkgen](https://voxgig.com/howto/first-sdk-with-sdkgen): Scaffold a project from your OpenAPI document with one non-interactive command, generate a TypeScript SDK, and read what the model made of your endpoints. - [How to give a Ruby SDK keyword arguments and Faraday middleware](https://voxgig.com/howto/ruby-sdk-keyword-arguments-and-faraday-middleware): Give a Ruby client keyword-argument methods and Data response objects, let callers add Faraday middleware, and prove a wrong keyword raises before any request. - [How to host docs question answering on Cloudflare Workers](https://voxgig.com/howto/host-docs-question-answering-on-cloudflare-workers): Embed the question with Workers AI, query a Vectorize index filtered to one docs version, and stream the answer with its sources over Server-Sent Events. - [How to implement Relay connections in a GraphQL schema](https://voxgig.com/howto/implement-relay-connections-in-a-schema): Build the edges, cursors, and pageInfo a Relay-style connection promises, and get the page flags right rather than guessing them. - [How to issue and rotate per-agent API keys for an MCP server](https://voxgig.com/howto/per-agent-api-keys-for-mcp): Give every agent installation its own key carrying the tools it may call, so a revocation stops one agent rather than every agent. - [How to judge whether an unofficial SDK is safe to depend on](https://voxgig.com/howto/judge-an-unofficial-sdk-before-adoption): Run six checks over a candidate package before you add it, and separate the facts that should stop adoption from the costs you are choosing to take on. - [How to keep an agent informed while an MCP tool runs for minutes](https://voxgig.com/howto/report-progress-from-a-long-running-tool): Send progress against the client's token, stop when the client cancels, and choose between one long call, a job id with a poll hint, and the tasks extension. - [How to keep test and live API keys from crossing environments](https://voxgig.com/howto/keep-test-and-live-keys-apart): Put the environment in the key itself and check it at process start, so a staging deployment holding a production credential refuses to run. - [How to let a coding agent customize a generated SDK safely](https://voxgig.com/howto/customise-a-generated-sdk-with-an-agent-safely): Point the agent at the levers under .sdk/, never at the generated tree, and prove with doctor and a regeneration diff that only the intended files move. - [How to let a coding agent probe a live API through an MCP server](https://voxgig.com/howto/probe-live-api-responses-through-an-mcp-server): Give a coding agent a read-only probe of the real API while it writes the client, and check what came back against the document before the agent hard-codes it. - [How to limit concurrency in a message worker](https://voxgig.com/howto/limit-concurrency-in-a-message-worker): Stop a worker pulling more messages than it can process, so a burst waits at the broker where an operator can see it instead of inside your process. - [How to list an MCP server in the official MCP registry](https://voxgig.com/howto/list-a-server-in-the-mcp-registry): Publish a server.json to the official MCP registry, prove your namespace from CI with GitHub OIDC, and keep the listing level with each release. - [How to load secrets in Lambda without a fetch per invocation](https://voxgig.com/howto/cache-lambda-secrets-across-invocations): Read an API key from Secrets Manager once per execution environment, not per invocation, through the extension, the SDK, or sekreto, and count the calls. - [How to loop over every page of a REST collection](https://voxgig.com/howto/loop-over-every-page-of-a-collection): Walk a paginated list endpoint to the end, read the three stop signals APIs actually send, and refuse to loop forever when a server repeats its cursor. - [How to make a Handlebars template produce byte-identical output](https://voxgig.com/howto/handlebars-byte-identical-output-every-run): Sort the model, keep helpers pure, normalise line endings and compile strict, so a Handlebars template renders the same bytes everywhere, checked with sha256sum. - [How to make queue consumer writes safe under redelivery](https://voxgig.com/howto/queue-consumer-writes-under-at-least-once): Derive an idempotency key from the message rather than from the attempt, so a broker that delivers at least once cannot charge a customer twice. - [How to map API parameters to CLI arguments and flags](https://voxgig.com/howto/map-api-parameters-to-cli-flags-and-arguments): Extend the command map with a parameter map: path parameters as positional arguments, query and header parameters as flags, and one input style for request bodies. - [How to measure drift between two AI-written clients](https://voxgig.com/howto/measure-drift-between-two-ai-written-clients): Compare two clients written from the same description and separate what one of them missed from what neither was told. - [How to merge nested config objects with predictable precedence](https://voxgig.com/howto/merge-nested-config-objects-with-precedence): Layer defaults, file, environment and flags with a deep merge so a later source overrides only the keys it sets, and clone first because merge mutates. - [How to migrate an API from offset to cursor pagination](https://voxgig.com/howto/migrate-offset-to-cursor-pagination): Move a list endpoint from offset to cursor pagination without breaking the clients still sending an offset, and show why the change is worth making. - [How to mock a generated SDK in your application tests](https://voxgig.com/howto/mock-a-generated-sdk-in-application-tests): Run one set of assertions about your code against a vendor SDK four ways, then bump the SDK a minor version and see which strategy noticed the change. - [How to model a polymorphic response with a discriminator](https://voxgig.com/howto/polymorphic-response-with-a-discriminator): Describe a response that comes in several shapes so a generator emits a tagged union rather than a bag of optional fields, using oneOf with a discriminator. - [How to name tools so an agent picks the right one from fifty](https://voxgig.com/howto/name-tools-so-agents-pick-the-right-one): Give every tool a noun and a verb, a description long enough to choose on, and a warning on anything destructive, then measure how often two tools still look alike. - [How to negotiate page size between an API and its clients](https://voxgig.com/howto/negotiate-page-size-with-clients): Clamp an over-large page size to your ceiling rather than rejecting it, say in the response what was served, and refuse only values that are not sizes. - [How to organize agent skills across many related repositories](https://voxgig.com/howto/organise-skills-across-a-multi-package-ecosystem): Keep one shared set of skills for the ecosystem, let each repository override what it needs, and report every shadowed name rather than letting one win in silence. - [How to paginate an API with a Ruby enumerator](https://voxgig.com/howto/paginate-an-api-with-a-ruby-enumerator): Wrap a paged list in an Enumerator that fetches pages as rows are pulled, so first(50) stays cheap, lazy.select stops early, and a 503 surfaces where you iterate. - [How to paginate an API with PHP generators](https://voxgig.com/howto/paginate-an-api-with-php-generators): Walk a paginated collection with a generator, so a caller writes one foreach, pages are fetched only as they are consumed, and an early break costs nothing. - [How to pin an API version from a client](https://voxgig.com/howto/pin-an-api-version-from-a-client): Send the API version you were built against on every request, and refuse a response that came back under a different one. - [How to poll a job status endpoint with backoff](https://voxgig.com/howto/poll-a-job-status-endpoint-with-backoff): Poll a job until it reaches a terminal state: honor Retry-After, back off with jitter when the server sends none, and stop at a deadline with the job id in hand. - [How to preload a generated client into a Node REPL](https://voxgig.com/howto/preload-a-generated-client-into-a-node-repl): Start a REPL with the client already built and its entities named, so exploring an API is one command rather than six lines of setup typed from memory. - [How to preview a regeneration as a diff before writing files](https://voxgig.com/howto/preview-a-regeneration-as-a-diff): See exactly what a generator would change before it changes anything, with a dry run that reports creates, replacements, and the files its mode protects. - [How to publish an OpenAPI document at a stable URL for agents](https://voxgig.com/howto/publish-openapi-at-a-stable-url): Serve the OpenAPI document as JSON and YAML at URLs that do not move, with the headers a browser needs, and a check that fails when the copies drift. - [How to publish security.txt for an API](https://voxgig.com/howto/publish-security-txt-for-an-api): Serve an RFC 9116 security.txt so a researcher who finds a bug in your API knows where to send it, and add the expiry check that stops the file going stale. - [How to push one CI template change to five hundred repositories](https://voxgig.com/howto/push-one-ci-change-to-many-repositories): Fan one workflow change out over hundreds of repositories with a dry run, a checkpoint and three known end states, against four ways to stop copying the file. - [How to rate limit by API key and tenant, not client IP](https://voxgig.com/howto/key-rate-limits-by-api-key-and-tenant): Enforce one limit per API key and a larger one per tenant, so a noisy key cannot spend a customer's whole allowance and one customer cannot spend yours. - [How to re-index docs on release without serving stale answers](https://voxgig.com/howto/reindex-docs-on-every-release): Build a new documentation index per release, promote it in one write, and fail a check whenever the live index was built from an older version than the docs. - [How to read a value at a nested path without null checks](https://voxgig.com/howto/read-a-nested-value-by-path): Read a deep value by a path held as a string, so a response mapper is a table of paths rather than a chain of optional accesses written out once per field. - [How to reconcile an extracted entity model with a domain model](https://voxgig.com/howto/reconcile-an-extracted-model-with-a-domain-model): Put the entity model extracted from the spec beside the one your team drew, give each disagreement a row and a decision, and fail the build when one has neither. - [How to refresh an access token once under concurrent requests](https://voxgig.com/howto/refresh-a-token-once-under-concurrent-requests): Hold the refresh in a single promise so concurrent callers await the same request, and callers that all see an expired token make one call to the token endpoint. - [How to remove left recursion from a PEG grammar](https://voxgig.com/howto/remove-left-recursion-from-a-peg-grammar): Rewrite a left-recursive rule so peggy accepts it, fold the action from the left to keep subtraction left-associative, and compare with ohm-js and nearley. - [How to report partial failure in a batch endpoint](https://voxgig.com/howto/report-partial-failure-in-a-batch-endpoint): Return one outcome per item when a batch of writes half succeeds, name each failed item by the id the client sent, and never answer 200 when nothing was written. - [How to retire a GraphQL field without versioning the schema](https://voxgig.com/howto/deprecate-graphql-fields-instead-of-versioning): Deprecate the field with a reason naming its replacement, count per-client usage over a release cycle, and let a CI gate hold the removal until the window passes. - [How to retry fetch calls with exponential backoff in Node.js](https://voxgig.com/howto/retry-fetch-with-backoff-in-node): Retry only the statuses the server meant as temporary, back off with full jitter, and honor Retry-After, so a shared outage does not become a stampede. - [How to return validation errors a client can map to a form](https://voxgig.com/howto/field-level-validation-errors-clients-can-map): Answer a bad request with an RFC 9457 problem document carrying one JSON Pointer entry per failing field, so a client can attach each message to an input. - [How to review an API against the OWASP API Security Top 10](https://voxgig.com/howto/review-an-api-against-owasp-api-top-ten): Review a running API against the ten risks of the 2023 edition, recording a replayable request and an owner for every risk, and rank the gaps you find. - [How to rotate API keys without breaking your clients](https://voxgig.com/howto/rotate-api-keys-without-breaking-clients): Run two keys at once, watch which one each caller uses, and retire the old one on evidence rather than on a date somebody picked. - [How to route outbound API calls through an egress proxy](https://voxgig.com/howto/route-outbound-calls-through-an-egress-proxy): Send every outbound call through one proxy that holds the credentials, enforces a per-vendor policy, and logs every decision it makes. - [How to run an in-memory mock of your API inside SDK tests](https://voxgig.com/howto/run-an-in-memory-mock-inside-sdk-tests): Build the client in test mode, seed it with records, and let the generated SDK answer its own calls from memory instead of reaching the network. - [How to run an MCP server against a mock API while you build tools](https://voxgig.com/howto/run-an-mcp-server-against-a-mock-api): Point your MCP tools at a mock you can script, so a rate limit or a 500 is one line of fixture rather than a bad afternoon on the real service. - [How to run authorization code with PKCE in a single-page app](https://voxgig.com/howto/pkce-in-a-single-page-app): Log a user into a browser-only app with PKCE, keep the tokens in memory, renew them silently after a reload, and prove nothing is ever written to local storage. - [How to run one service locally and at the edge without forking it](https://voxgig.com/howto/run-one-service-locally-and-at-the-edge): Write the HTTP front once in the fetch shape, give Node a twenty-line adapter, and run one request suite against both fronts and a stand-in that has no Node globals. - [How to run service startup steps in a fixed order](https://voxgig.com/howto/run-service-startup-steps-in-order): Turn an improvised startup function into an ordered list of named steps that can stop the boot and say why, and pin readiness to the store actually being open. - [How to sandbox an agent's shell and code execution](https://voxgig.com/howto/sandbox-agent-shell-and-code-execution): Run what an agent executes inside a boundary with no credentials, a scratch filesystem and a closed network, in Docker, a sandbox service or an OS-level sandbox. - [How to sanitize tool results before they re-enter the prompt](https://voxgig.com/howto/sanitise-tool-results-before-reprompting): Extract readable text, strip zero-width characters, normalize to NFKC, cut to a byte budget, and wrap the result in a delimiter the system prompt names as data. - [How to scaffold a Python API client project with Cookiecutter](https://voxgig.com/howto/scaffold-a-python-project-with-cookiecutter): Turn a Python client layout into a Cookiecutter template with derived names, a hook that survives a second run, and a test that bakes it into a temporary directory. - [How to serve your OpenAPI examples as mock responses](https://voxgig.com/howto/serve-openapi-examples-as-mock-responses): Wire the examples in your OpenAPI description to what the mock server returns, so the docs, the tests and the mock all show one payload. - [How to set an SLO for a third party API you depend on](https://voxgig.com/howto/set-slos-for-a-third-party-api): Set an objective for a dependency you do not run, measured from your client, with burn-rate alerts that page when the provider degrades, not when you ship a bug. - [How to set robots.txt rules for each AI crawler](https://voxgig.com/howto/set-robots-rules-for-ai-crawlers): Separate the crawlers that train models from the fetchers acting for a person right now, and check each rule against the matching algorithm before you ship it. - [How to share an API response cache across many workers with Redis](https://voxgig.com/howto/share-a-response-cache-across-workers-with-redis): Move a per-process response cache into Redis so forty workers pay one miss per key, with a lock on the miss and a policy that keeps cookies out of the shared store. - [How to share one MCP server config across several editors](https://voxgig.com/howto/share-one-mcp-config-across-editors): Keep Claude Code, Cursor, VS Code, and Cline on the same MCP servers by rendering four editor files from one source, and see why a copied file loads zero servers. - [How to ship a changelog inside your published package](https://voxgig.com/howto/ship-a-changelog-inside-the-package): Put the changelog in the published artifact, and check in CI that it ships and that its newest entry matches the version being released. - [How to split and bundle a large OpenAPI document](https://voxgig.com/howto/split-and-bundle-an-openapi-document): Break a multi-thousand-line description into per-resource files, then produce the single bundled document most generators expect, without losing component names. - [How to stop a coding agent inventing endpoints not in the spec](https://voxgig.com/howto/stop-a-coding-agent-inventing-endpoints): Make an invented path a compile error, refuse the rest at a validation proxy, and review casts as well as tests, because an instruction on its own leaks. - [How to stub outbound HTTP calls in Node tests with nock](https://voxgig.com/howto/stub-outbound-node-http-calls-with-nock): Intercept outbound requests in-process, assert on what your code sent as well as received, and turn off real network access so an unstubbed call fails. - [How to tag SDK calls with session and request ids](https://voxgig.com/howto/tag-sdk-calls-with-session-and-request-ids): Send three identifiers with three lifetimes, so a support question about one call can be answered from the service's own logs. - [How to tell a denied outbound call apart from a vendor outage](https://voxgig.com/howto/diagnose-an-outbound-call-that-was-denied): Work out in a minute whether your own egress policy, the network, or the vendor stopped a call, by making the denial an error code the caller can branch on. - [How to tell an entity-shaped SDK from an endpoint-shaped one](https://voxgig.com/howto/measure-entity-versus-endpoint-shaped-output): Count the nouns, the operations per noun, and how many names start with a verb, so a claim about SDK shape is a measurement rather than a preference. - [How to test a plugin through every lifecycle stage](https://voxgig.com/howto/test-a-plugin-through-every-lifecycle-stage): Drive one plugin from registration through activation to deactivation inside a test, and assert what it released, without touching a real network. - [How to test an API for broken object level authorization](https://voxgig.com/howto/test-for-broken-object-level-authorization): Try every identifier with every credential and assert that a caller who does not own a resource gets the same answer as one asking for something that does not exist. - [How to test interactive prompts and terminal behavior in a CLI](https://voxgig.com/howto/test-interactive-prompts-and-tty-behaviour): Test a confirmation prompt without a real terminal, by passing the streams and the terminal flag in rather than reading them from the process. - [How to time out fetch calls with AbortSignal in Node.js](https://voxgig.com/howto/time-out-fetch-with-abortsignal-in-node): Put a hard deadline on every fetch call with AbortSignal.timeout, merge it with a caller's own signal, and tell a deadline apart from a cancellation. - [How to translate upstream API errors behind your own API](https://voxgig.com/howto/translate-upstream-errors-behind-your-api): Decide what your API returns when a provider it depends on fails, without leaking the provider's status codes, messages, or credential problems to callers. - [How to turn an exploratory REPL session into a script](https://voxgig.com/howto/save-a-repl-session-as-a-script): Convert a REPL history into a script that runs, by dropping the lines that threw, the expressions typed to look at a value, and the REPL's own commands. - [How to upgrade an MCP server to a newer protocol revision](https://voxgig.com/howto/upgrade-an-mcp-server-to-a-newer-revision): Move a server from a handshake-era revision to 2026-07-28 by upgrading the SDK, then prove every client you support still connects with one scripted matrix run. - [How to upload a large file with resumable chunks](https://voxgig.com/howto/upload-a-large-file-with-resumable-chunks): Resume an upload from the last byte the server confirmed after a dropped connection or a closed tab, with tus, S3 multipart, Google resumable uploads, or your own. - [How to validate JSON model output before you use it](https://voxgig.com/howto/validate-json-model-output-in-typescript): Get a typed value out of a model response that is only mostly JSON, and refuse the responses that are the wrong shape instead of letting them into your code. - [How to validate responses against the OpenAPI document at runtime](https://voxgig.com/howto/validate-responses-against-the-openapi-document): Build a validator from the response schema in your OpenAPI document and run it over real responses, so a service that stops matching its description fails. - [How to verify a Standard Webhooks signature in PHP](https://voxgig.com/howto/verify-a-standard-webhooks-signature-in-php): Check the signature, the timestamp and the raw body of an incoming webhook in PHP, and keep two secrets valid so a rotation costs nobody a delivery. - [How to verify every error response matches one schema](https://voxgig.com/howto/verify-every-error-response-matches-one-schema): Prove that no endpoint can return an error body outside your problem schema, using a lint over the description and a runtime check against the running service. - [How to wire an API client into the OpenAI Agents SDK](https://voxgig.com/howto/wire-an-api-client-into-openai-agents-sdk): Register a typed client's operations as function tools, run the loop, hand off between two agents on one client, and keep a failed call from ending the run. - [How to wrap an SDK transport in a middleware chain](https://voxgig.com/howto/wrap-an-sdk-transport-with-middleware): Compose retry, caching, authentication and tracing as layers around one transport, so each concern is written once and the order is declared rather than implied. - [How to write a task prompt that gets an API integration done](https://voxgig.com/howto/write-a-task-prompt-for-an-api-integration): Name the spec, the auth scheme, the language, the test command, and the done criteria in one task prompt, then check the agent's result against them yourself. - [How to write a validator whose schema looks like the data](https://voxgig.com/howto/write-a-schema-that-looks-like-the-data): Write the schema as an example of an accepted value, with constructors for types and literals for defaults, so schema and sample read side by side. - [How to write CLI help that people and agents can both use](https://voxgig.com/howto/help-text-people-and-agents-can-use): Describe the command surface once, render it as text and as data, and lint the result so a command cannot ship with an example that does not run. - [All how-to guides](https://voxgig.com/howto): the index, grouped by section and topic. ## Machine-readable resources - [AGENTS.md](https://voxgig.com/AGENTS.md): instructions for coding agents, including the rules of engagement. - [Full LLM index](https://voxgig.com/llms-full.txt): every SDK in the catalog as a link list. - [Whole catalog as JSON](https://voxgig.com/api/sdk/catalog.json) - [Whole catalog as CSV](https://voxgig.com/sdk/voxgig-sdk.csv) - [API catalog](https://voxgig.com/.well-known/api-catalog): RFC 9727 linkset. - [MCP server card](https://voxgig.com/.well-known/mcp/server-card.json) - [Agent Skills index](https://voxgig.com/.well-known/agent-skills/index.json) - [Sitemap](https://voxgig.com/sitemap-index.xml) - [Security contact](https://voxgig.com/.well-known/security.txt): RFC 9116. ## Optional - [Podcast](https://voxgig.com/podcast): Fireside with Voxgig, 249+ episodes since 2018. [RSS](https://voxgig.com/podcast/rss.xml) - [Blog](https://voxgig.com/voxgig-blog) - [Privacy](https://voxgig.com/privacy) - [Policy statements](https://voxgig.com/notices) - [Generator source](https://github.com/voxgig/sdkgen): the open-source generator on GitHub. - [Generated SDK repositories](https://github.com/voxgig-sdk)