wretch VS ky

In conclusion, whether you choose axios, fetch, or an alternative like wretch, your focus should be on writing clear, maintainable, and robust code. Understanding the strengths and weaknesses of each tool will empower you to make informed decisions and build applications that are not only functional but also resilient and enjoyable to develop.

This package does it quite nicely https://github.com/elbywan/wretch

One newer option, which is a very thin wrapper around Fetch much like Redaxios, is Wretch. Wretch is unique in that it largely still feels like fetch, but gives you helpful methods for handling common statuses which can chain together nicely:

It would be better with a link to kick things off so boomers can choose to read about it instead https://github.com/elbywan/wretch

For ajax, I never use Axios anymore, I always use Wretch these days.

Wretch Wretch on the other hand takes the function chaining approach. It split common error types into separate helper methods so you don't need to result in an interceptor every time

You might be interested in Wretch, it's very lightweight and has a nice middleware facility.

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.