ky VS zod

I usually reach for ky these days since it's an extremely lightweight wrapper over `fetch` - basically just adds a few niceties

https://github.com/sindresorhus/ky

From the readme:

- Simpler API

- Method shortcuts (ky.post())

- Treats non-2xx status codes as errors (after redirects)

- Retries failed requests

- JSON option

- Timeout support

- Upload and download progress

- Base URL option

- Instances with custom defaults

- Hooks

- Response validation with Standard Schema (Zod, Valibot, etc.)

- TypeScript niceties (e.g., .json() supports generics and defaults to unknown, not any)

Of course, this is only for projects where I have to make a lot of HTTP requests to a lot of different places where these niceties make sense. In most cases, we're usually using a library generated from an OpenAPI specification and fall back to `fetch` only as an escape hatch.

Batch 100 API calls with Promise.all and the server returns 429. Add retry and transient network errors self-heal — but there's still no cap on how many run at once. ky handles per-request reliability. p-limit controls overall throughput. Both together is the complete solution.

Every project using fetch ends up with the same boilerplate: if (!response.ok) throw new Error(...). Add retry and you're writing a loop. Add timeout and you're pulling out AbortController. ky wraps all of that. 4KB, zero dependencies.

This came up while building convenience plugins for ffetch, a lightweight fetch wrapper focused on keeping native semantics intact. Libraries like ky solve the ergonomics problem by introducing a custom Response-like object, which works great until something outside the library expects a plain Response. I wanted a different path.

https://github.com/sindresorhus/ky?tab=readme-ov-file#how-is...

Resources I used for writing this article: Ky: https://www.npmjs.com/package/@smeijer/ky?activeTab=readme https://github.com/sindresorhus/ky Axios: https://www.npmjs.com/package/axios?activeTab=readme https://axios-http.com/docs/intro

API-routes provide regular endpoints through folder hierarchy, giving you full control over request-response objects and middleware. You can use any HTTP client library—mine is ky.

This post shows how to build a small todo MCP server with Node.js using the official @modelcontextprotocol/sdk package and Zod schemas.

This pattern works cleanly with Zod and React Hook Form. Zod schemas can infer TypeScript types directly, so you define validation rules and get the type for free:

Zod closes that gap by validating shape at runtime. The friction is hand-writing the schema. So I built a small in-browser tool that does it for you — paste a JSON sample, get a runnable z.object. This post is about the four non-obvious algorithm choices that came out of that build.

Libraries like React Hook Form, Formik, and Zod for schema validation make the per-step validation architecture manageable and well-tested. React and other component-based frameworks make the state sharing pattern clean with context or a global store.

5. Add runtime validation. Use Zod or Valibot to validate that the API actually sends what your types describe. The converter gives you structure; a schema library gives you runtime guarantees.

When writing runtime validation in TypeScript, Zod is usually the first choice.

Do you validate the data your backend API returns? Most people just use as to cast the type and hope the data matches expectations. Zod lets you define a schema once and get both runtime validation and TypeScript types — no more trust-based programming.

Zod is a TypeScript-first schema declaration and validation library. It is widely used in Next.js projects to bridge the gap between runtime data validation and compile-time type safety.

Every serious TypeScript project uses Zod for runtime validation. The team loves it — one schema, end-to-end type inference, parse-don't-validate all the way down. Done, sorted, move on.

This post walks through a pipeline where you define your data shape once as a Zod schema on the backend, and every other layer (API docs, frontend types, React Query hooks) is generated from it automatically using Orval. Change the schema, regenerate, and TypeScript tells you exactly what broke. Across the entire stack.