How we make this list: we compare pricing pages, product documentation and public user reviews. Ratings come from G2, Capterra or Trustpilot, with the date we checked them.
Key takeaways
- ky is the best general fetch replacement for Deno, with retries, hooks, and JSON handling in a tiny fetch-native package.
- undici is the official Node.js HTTP client and the engine behind Node fetch, suited to high-performance backend services.
- got fits Node.js-only backends that want a full-featured client with pagination, caching, and retries.
- ofetch is the natural pick for Nuxt and Nitro stacks, with smart JSON handling and server-friendly defaults.
- axios remains viable for teams with existing interceptor code, though a 2026 supply-chain incident pushed many teams to leaner clients.
Quick comparison
| Tool | Best for | Starting price | Free plan |
|---|
 ky | Universal fetch-native client | Free | Yes |
 undici | Node.js high-performance HTTP | Free | Yes |
 got | Full-featured Node.js client | Free | Yes |
 ofetch | Nuxt and Nitro stacks | Free | Yes |
 wretch | Tiny fetch wrapper | Free | Yes |
 axios | Teams with interceptor code | Free | Yes |
 node-fetch | Node.js fetch polyfill | Free | Yes |
 cross-fetch | Universal fetch across runtimes | Free | Yes |
Is your product missing or out of date?
We review this list regularly. Vendors can request a listing, send updated pricing or ask about featured placement.
The best Deno alternatives to fetch API
Starting priceFree
Free planYes
ky, by Sindre Sorhus, is a tiny and elegant HTTP client built directly on the Fetch API. In Deno it feels native: no polyfill, no Node-only dependency, just fetch with better defaults. JSON request bodies serialize automatically, responses parse with a single method call, and retries with backoff, timeouts, and beforeRequest and afterResponse hooks cover the gaps that make raw fetch verbose.
The practical advantage is portability. Code written with ky runs identically in Deno, browsers, Cloudflare Workers, and Vercel Edge Functions, since all of them implement fetch. The limits are the edges of Node.js-specific networking: ky does not expose undici agents or low-level socket controls. For most Deno applications, from API clients to edge handlers, ky is the first alternative to reach for.
What we like- Built on native fetch, so it runs in Deno, browsers, and edge runtimes
- Retries, timeout, and hooks included
- Tiny bundle near 2.5KB
Watch out for- No Node.js http module features such as agents and streams depth
- Migration from axios interceptors needs rework
Starting priceFree
Free planYes
undici is the HTTP client that powers Node.js fetch itself: Node 18 shipped fetch as experimental, Node 21 made it stable, and Node 22 ships undici v6 underneath. It offers connection pooling, pipelining, and a dispatcher model that makes high-throughput backend services fast. Interceptors and diagnostics channels let teams instrument requests at the transport level without touching call sites.
The catch for this list is runtime fit. undici is Node.js only, so it cannot run in Deno directly. It belongs here because many Deno developers also maintain Node services, and because understanding undici explains what Deno fetch does under the hood in its own runtime. For a Node backend that needs maximum throughput, undici is the strongest choice; for Deno-only code, ky is the better fit.
What we like- Official Node.js HTTP client with zero dependencies
- Connection pooling and pipelining for speed
- Diagnostics and interceptors at transport level
Watch out for- Node.js only, so it does not run in Deno or browsers
- Lower-level API needs more code for simple requests
Starting priceFree
Free planYes
got is the most complete Node.js HTTP client in this list. It handles pagination helpers, response caching, retries with backoff, hooks, and progress events, all with a clean promise API. Its download base runs near 50 million weekly installs, and it is actively maintained as ESM with tree-shaking support.
got shares undici's runtime limit: it depends on Node.js http internals, so it does not run in Deno, browsers, or edge runtimes. Teams building edge-deployed middleware must avoid it. For a Node backend that makes many outbound API calls and wants retries, caching, and pagination without hand-rolling them, got is the most productive option.
What we like- Pagination, caching, retries, and hooks in one package
- ESM and tree-shakeable
- Huge download base with long maintenance history
Watch out for- Node.js only
- Depends on a chain of small packages
- Migration from axios is moderate work
Starting priceFree
Free planYes
ofetch, from the UnJS team behind Nuxt and Nitro, is a fetch wrapper tuned for server frameworks. It parses JSON automatically, throws useful errors for failed responses, and offers onRequest, onResponse, and onResponseError hooks that mirror axios interceptors with less code. It runs in browsers, Node.js, and workers, so the same client works across a Nuxt app and its server routes.
The trade is ecosystem fit. ofetch shines inside Nuxt and Nitro projects, where its defaults match the framework's server utilities. Outside that world it is still a fine client, but ky offers a smaller bundle and a larger general audience. For a Nuxt team choosing a fetch alternative, ofetch is the natural default.
What we like- Smart JSON and error handling
- Interceptor-style hooks
- Runs in browsers, Node.js, and workers
Watch out for- Tied conceptually to the UnJS ecosystem
- Smaller community than ky or axios
Starting priceFree
Free planYes
wretch is a tiny wrapper around fetch with a chainable API that reads almost like sentences. A request builds through method, URL, body, and error handling steps, which makes call sites easy to read. At roughly 2.1KB with zero dependencies, it adds almost nothing to a bundle, and it runs wherever fetch runs, including Deno and browsers.
The limits are scale and ecosystem. wretch has fewer built-in features than ky, such as advanced retry configuration, and its plugin ecosystem is modest. Teams that want a minimal, readable fetch wrapper without adopting a larger client will like wretch. Teams that need retries, caching, and hooks out of the box should pick ky or ofetch instead.
What we like- Tiny bundle near 2.1KB with zero dependencies
- Intuitive chainable syntax
- Works in browsers and Node.js
Watch out for- Smaller community and fewer advanced features than ky
- Plugin ecosystem is modest
Starting priceFree
Free planYes
axios remains the most widely known HTTP client, and its interceptor model is the reason many teams stay. Request and response interceptors handle auth tokens, logging, and 401 redirects globally, and automatic JSON transformation plus progress tracking cover common needs. A decade of tutorials means new developers already know it.
The case for moving away hardened in 2026, when a compromised axios release reached npm and exposed millions of weekly downloads to credential-harvesting code before it was yanked within hours. The incident lasted under six hours, but it pushed many teams to reassess large legacy clients with broad dependency exposure. For a team with deep axios interceptor code, migration is real work, and staying is defensible with pinned versions and lockfile audits. For new Deno code, ky or ofetch is the cleaner start.
What we like- Familiar interceptor model
- Automatic JSON handling
- Upload and download progress tracking
- Huge existing codebase
Watch out for- Larger bundle near 13 to 15KB
- 2026 supply-chain incident shook confidence
- Browser build historically used XMLHttpRequest
Starting priceFree
Free planYes
node-fetch exists to give Node.js the Fetch API, and it mattered greatly before Node 18 shipped fetch natively. It implements the WHATWG fetch standard for Node, so code written against fetch runs on older runtimes. It is lightweight and well understood.
For Deno developers, node-fetch is mostly a reference point rather than a tool: Deno already ships fetch natively, so there is nothing to polyfill. It still belongs on this list because many codebases straddle Deno and older Node versions, and because its API shaped what developers expect from fetch. New projects on modern runtimes should use native fetch or ky instead.
What we like- Brings the Fetch API to older Node.js versions
- Familiar fetch semantics
- Lightweight
Watch out for- Largely unnecessary on Node 18 and later, where fetch is built in
- Does not run in Deno, which already has fetch
Starting priceFree
Free planYes
cross-fetch provides a universal WHATWG fetch implementation for Node, browsers, and React Native behind a single import. That simplicity is its whole pitch: one dependency, one API, no runtime branching in application code. Teams shipping a library that must run everywhere often reach for it.
The thinness is also the limit. cross-fetch adds no retries, hooks, timeout helpers, or JSON conveniences, so application code still handles those by hand. Its maintenance pace is quieter than ky's or ofetch's. For a library author who needs fetch everywhere with minimal surface, cross-fetch works. For an application that needs a real client, ky is the better investment.
What we like- One fetch import for Node, browsers, and React Native
- Minimal API surface
- Easy migration path
Watch out for- Thin wrapper with no retries, hooks, or JSON helpers
- Maintenance is quieter than ky or ofetch
How we chose
We compared each client against what Deno developers actually need from a fetch alternative: runtime support, bundle size, retries, hooks, JSON handling, and maintenance health. All eight tools are free and open source under MIT or similar licenses, so pricing is not a differentiator. We flagged where a tool is Node-only, since that decides whether it can run in Deno at all, and we noted the 2026 axios supply-chain incident because it changed how many teams weigh dependency risk.
What to check before you pick
Match the runtime first. If code must run in Deno, browsers, and edge runtimes, the shortlist is ky, ofetch, wretch, and cross-fetch; got and undici are Node-only. Then weigh features against bundle: ky covers retries, hooks, and JSON in 2.5KB, while axios covers more at 13 to 15KB. Check three practical things before committing: whether timeouts use AbortSignal cleanly, how retries handle 429 rate limits with backoff, and whether interceptors or hooks cover your auth refresh flow. Pin dependency versions and audit lockfiles, especially after the 2026 axios incident, and prefer zero-dependency clients where the feature set allows. That discipline matters more than any single feature comparison, since a compromised dependency can affect every request your application makes.
Frequently asked questions
Does Deno have fetch built in?
Yes. Deno ships the Fetch API natively, so simple requests need no library. Alternatives add retries, hooks, JSON helpers, and better error handling on top of fetch.
Which fetch alternative is best for Deno?
ky is the best general pick: fetch-native, tiny, and portable across Deno, browsers, and edge runtimes, with retries and hooks included.
Why not just use axios in Deno?
axios works in Deno through its fetch adapter, but it is heavier, and its 2026 supply-chain incident pushed many teams toward leaner fetch-native clients. Existing axios code is still valid with pinned versions.
What is the difference between ky and ofetch?
ky is a general-purpose fetch client with a tiny bundle. ofetch is tuned for Nuxt and Nitro, with server-friendly defaults and error handling that matches those frameworks.
Do I need undici or got for Deno?
No. Both are Node.js only and cannot run in Deno. They matter if you also maintain Node services or want to understand what powers Node fetch.
How do I handle retries and timeouts with native fetch?
Use AbortSignal.timeout for timeouts and a small retry wrapper with backoff for transient failures, or pick ky, which includes both features out of the box.
Sources we checked (8)
- https://github.com/sindresorhus/ky
- https://github.com/nodejs/undici
- https://github.com/sindresorhus/got
- https://github.com/unjs/ofetch
- https://github.com/elbywan/wretch
- https://axios-http.com/docs/intro
- https://github.com/node-fetch/node-fetch
- https://github.com/lquixada/cross-fetch
Is your product missing or out of date?
We review this list regularly. Vendors can request a listing, send updated pricing or ask about featured placement.
Shihab Mia · Founder, Rankite
Shihab has 5+ years in B2B and SaaS SEO. He writes Rankite's software buying guides from pricing pages, documentation and public user reviews. More about Shihab.