openFetchHTTP that feels native to fetch

Interceptors, middleware, Standard Schema JSON, retry lifecycle hooks, and memory cache — fetch-only for Node 18+, the edge, and modern browsers.

Get started

npm

GitHub

Open in your assistant

Ask ChatGPT

Ask Claude

Pre-fills a prompt that points at the docs site and . If the message box is empty, paste the prompt from the address bar or type it manually — URL prefill behavior depends on the product.

Bundle Size

Fetch-only transport

One code path on top of standard fetch — Node, Bun, Deno, Workers, and modern browsers without mandatory polyfills.

Interceptors & middleware

Request/response interceptors plus composable middleware for auth, logging, retries, and caching in a predictable order.

Retry & in-memory cache

Optional retry with backoff and GET/HEAD memory cache with TTL / SWR-style patterns when you opt in.

Structured errors & safety hooks

OpenFetchError with stable codes, optional URL guard for untrusted URLs, and helpers for safe logging.

Tree-shakable entrypoints

Import the core client or add plugins and the fluent sugar API from dedicated subpaths.

Server components friendly

No window assumption — suitable for SSR, APIs, and React Server Components patterns.

Schema validation & Ky-style ergonomics

Optional Standard Schema on JSON, throwHttpErrors, native Request input, sync init hooks, retry onAfterResponse / OpenFetchForceRetry — see Features & pipeline.

At a glance

Capability	openFetch	Axios	ky
Transport	openFetchfetch	AxiosXHR (default in browsers)	kyfetch
Runtime deps	openFetchZero	AxiosOwn stack	kyZero
Node H2 / fetch dispatcher	openFetch Opt-in: user `undici`; `dispatcher` / `allowH2`	AxiosNode adapters	ky Opt-in: user `undici` (docs)
Instance & defaults	openFetch createClient	Axios axios.create	ky ky.create
Request / response interceptors	openFetch Both	Axios Both	ky Hooks only
Composable middleware	openFetch use()	Axios—	ky—
transformRequest / transformResponse	openFetch Ordered arrays on config	Axios Built-in transform pipeline	ky Hooks (no config arrays)
Validated JSON (Standard Schema)	openFetch jsonSchema + fluent .json(schema)	Axios Bring your own (e.g. Zod in transform)	ky .json(schema)
HTTP status gate	openFetch validateStatus + throwHttpErrors	Axios validateStatus	ky throwHttpErrors
Native Request + sync init	openFetch request(Request) + init[]	Axios Config-based (no first-class init[])	ky Request + init hooks
Retry with backoff (opt-in)	openFetch Plugins + onAfterResponse / ForceRetry	Axios Separate	ky Retry + afterResponse hook
GET memory cache (TTL / SWR)	openFetch createCacheMiddleware + store	Axios Third-party / DIY	ky—
Uniform client response	openFetch OpenFetchResponse	Axios AxiosResponse	ky Response / parsed
Errors, safe logs, URL guard	openFetch toShape, redact URL, mask headers, URL guard	Axios AxiosError; DIY redaction	ky Typed errors; DIY redaction
Timeout vs user cancel	openFetch ERR_TIMEOUT vs ERR_CANCELED	Axios Often AbortError for both	ky TimeoutError vs AbortError
Fluent client + memo	openFetch createFluentClient + .memo()	Axios—	ky Native chaining (no bundled memo)
POST retry idempotency key	openFetch Opt-in auto header (retry plugin)	Axios Manual / interceptors	ky Manual
Edge & RSC friendly	openFetch Uses fetch	Axios Adapters	ky fetch

Bundle size depends on your toolchain and imports. openFetch layers practical fetch ergonomics: Standard Schema JSON, status gates, Request + sync init, retry lifecycle hooks, ERR_TIMEOUT vs cancel — see Features & pipeline for the full diagram.

Same request — three HTTP clients

The EscuelaJS categories API returns a JSON array. Below: openFetch, Axios, and ky.

openFetch — shared defaults, structured response, and room for interceptors/middleware:

import openFetch from "@hamdymohamedak/openfetch";

const res = await openFetch.get(
  "https://api.escuelajs.co/api/v1/categories"
);
// res.data, res.status, res.headers, res.config

Axios — familiar API; different transport defaults in the browser:

import axios from "axios";

const res = await axios.get(
  "https://api.escuelajs.co/api/v1/categories"
);
// res.data, res.status, res.headers, res.config

ky — minimal API on top of fetch:

import ky from "ky";

const data = await ky
  .get("https://api.escuelajs.co/api/v1/categories")
  .json();

Why developers reach for a client layer

Shared configuration — baseURL, headers, timeouts, and unwrapResponse once per createClient instance.
Cross-cutting behavior — attach auth, tracing, feature flags, and error normalization via interceptors and middleware.
Resilience — retry policies and caching strategies without rewriting every call site.
Predictable errors — map HTTP and network failures to typed errors instead of ad-hoc try/catch parsing.

openFetch targets teams that want those benefits while staying on fetch everywhere the platform already provides it.

Documentation

Visual guide (hands-on) — animated request flow + practical examples for every major feature
Getting started — install, default export, createClient, first requests
HTTP methods — GET, POST, PUT, PATCH, DELETE, request(), bodies and query params
React & Vue — hooks, composables, shared clients, RSC notes
Configuration — full request config, rawResponse, merge rules, helper exports
Features & request pipeline — full feature list, merge → dispatch diagrams, retry hooks
Plugins & fluent API — @hamdymohamedak/openfetch/plugins, @hamdymohamedak/openfetch/sugar
Interceptors & middleware — execution order, dispatch internals, use(), custom middleware
Retry & cache — retry budgets, idempotency, createCacheMiddleware, TTL / SWR
Errors & security — OpenFetchError, codes, guards, safe logging, assertSafeHttpUrl
AI assistants & skills — concise API guidance for models; SKILL.md skill bundle and skills.sh / Agent Skills format

Public API (summary)

Export	Role
default	Pre-built `createClient()` instance
`createClient` / `create`	New client with optional `initialDefaults`
`createFluentClient`	Callable fluent URL chains (from `/sugar`)
`retry`, `timeout`, `hooks`, `debug`, `strictFetch`	Middleware plugins (from `/plugins`)
`OpenFetchError`, `isOpenFetchError`, `isHTTPError`, `isTimeoutError`	Typed errors + guards
`SchemaValidationError`, `isSchemaValidationError`	Standard Schema failures on JSON
`OpenFetchForceRetry`, `isOpenFetchForceRetry`	Force another retry attempt from `onAfterResponse`
Standard Schema types	`StandardSchemaV1`, `StandardSchemaV1InferOutput`, …
`InterceptorManager`	Low-level interceptor stack
`createRetryMiddleware`	Retry middleware factory
`MemoryCacheStore`, `createCacheMiddleware`, `appendCacheKeyVaryHeaders`	In-memory cache
`maskHeaderValues`, `cloneResponse`, idempotency helpers	Logging and retry ergonomics
Types	`OpenFetchConfig`, `OpenFetchResponse`, `Middleware`, `OpenFetchClient`, etc.
`assertSafeHttpUrl`	Optional SSRF-style guard for literal IP/localhost in URLs

Requirements

Node.js 18+ or any runtime with fetch and AbortController.

Source & package

GitHub: openfetch-js/OpenFetch
npm: @hamdymohamedak/openfetch

Other languages

Browse all translations.

openFetchHTTP that feels native to fetch

Fetch-only transport

Interceptors & middleware

Retry & in-memory cache

Structured errors & safety hooks

Tree-shakable entrypoints

Server components friendly

Schema validation & Ky-style ergonomics

At a glance ​

Same request — three HTTP clients ​

Why developers reach for a client layer ​

Documentation ​

Public API (summary) ​

Requirements ​

Source & package ​

Other languages ​