Axios

Axios is the most widely used promise-based HTTP client for JavaScript, running unmodified in both browsers (via XHR/fetch) and Node.js (via the http module). It wraps the differences between these environments behind a single consistent API, so a request written once works the same way whether it executes client-side or server-side.

Beyond basic GET/POST calls, Axios provides request and response interceptors, automatic JSON serialization/deserialization, client-side XSRF protection, upload/download progress tracking, request cancellation via AbortController, and configurable instances with their own defaults. Its long history (since 2014), massive adoption (100M+ weekly downloads), and near-universal familiarity make it a default choice for teams that want a battle-tested HTTP layer without hand-rolling fetch boilerplate.

What You Get

• A single axios instance with .get/.post/.put/.patch/.delete method aliases plus a callable axios(config) form
• Request and response interceptor chains for adding auth headers, logging, retries, or transforming payloads centrally
• Automatic JSON request/response transforms and automatic multipart/form-urlencoded serialization
• Built-in request cancellation via native AbortController (and the deprecated CancelToken for legacy code)
• Per-instance configuration via axios.create(), so different base URLs/headers/timeouts can coexist in one app
• First-class TypeScript typings shipped in the package itself (index.d.ts / index.d.cts)
• Upload/download progress events and client-side CSRF (XSRF) token handling out of the box

Common Use Cases

• Calling REST/JSON APIs from a frontend SPA where fetch’s verbosity (manual JSON parsing, no built-in timeout) is a pain point
• Sharing one HTTP client configuration (base URL, auth header, interceptor-based token refresh) across a Node.js backend service
• Uploading files with progress bars using the onUploadProgress callback and automatic multipart/form-data handling
• Centralizing error handling and retry logic for all outbound API calls through a single response interceptor
• Isomorphic code that needs to issue identical HTTP requests in both a Next.js server component and the browser bundle

Under The Hood

Architecture

The library is organized around lib/core/Axios.js, whose _request() method is the heart of the request pipeline: it merges the instance’s defaults with the per-call config (mergeConfig.js), flattens per-method headers into a single AxiosHeaders instance, builds an interceptor chain (InterceptorManager.js) that wraps dispatchRequest.js, and executes that chain as a promise sequence (or synchronously first if all interceptors are marked synchronous, an optimization for hot paths). dispatchRequest.js transforms the outgoing body via transformData.js, resolves the correct transport through lib/adapters/adapters.js (http.js for Node, xhr.js for browsers, fetch.js for the newer Fetch-based adapter), invokes it, and transforms the response body back. lib/axios.js is the composition root: it instantiates a default Axios instance via createInstance(), then bolts on static helpers (isCancel, CancelToken, mergeConfig, AxiosHeaders, HttpStatusCode) and the .create() factory for spinning up independently configured instances.

Tech Stack

Axios is dependency-light for a library this widely used: runtime dependencies are follow-redirects (HTTP redirect handling for the Node adapter), form-data (multipart bodies in Node), https-proxy-agent, and proxy-from-env. The source is plain ES modules ("type": "module" in package.json) with no build-time framework; distribution bundles for CJS, ESM, and browser targets are produced via Rollup (rollup.config.js) and Gulp (gulpfile.js), with Babel used to transpile down for older browser targets. TypeScript typings are hand-maintained (index.d.ts/index.d.cts) rather than generated from source, since the implementation itself is plain JS.

Code Quality

The test suite is substantial and organized by concern: tests/unit/core, tests/unit/adapters, tests/unit/helpers, tests/unit/cancel, and tests/unit/utils hold roughly 98 test files, run through Vitest across both a Node (‘unit’) project and a real-browser (‘browser’/‘browser-headless’) project via @vitest/browser. There’s also a dedicated tests/smoke suite that verifies the published CJS/ESM/Deno/Bun builds actually load correctly post-packaging — a good sign for a package whose main risk is bundler/runtime interop, not core logic. Error handling is deliberate rather than an afterthought: AxiosError.js implements a toJSON()-safe, circular-reference-safe config serializer with an explicit secret-redaction pass (redactConfig), and Axios.js’s request() wrapper carefully preserves and extends stack traces across the async boundary so errors thrown deep in an adapter still point back to the caller’s call site.

API Design The public surface is deliberately small and fetch-adjacent: call axios(url) or axios.get/post/put/patch/delete(url, [data], [config]), get back a promise that resolves to a normalized { data, status, headers, config } response or rejects with a typed AxiosError. Interceptors (axios.interceptors.request.use(...)) are the main extension point and read naturally as middleware. The one wrinkle for newcomers is the historical split between the legacy CancelToken cancellation API (deprecated but still present) and the modern AbortController support — the docs steer users to the latter, but both remain in the API surface for backward compatibility.