A light-weight module that brings Fetch API to node.js. 

A light-weight module that brings Fetch API to node.js

timothygu

akepinski

bitinn

endless

node-fetch-bot

node-fetch

import {FormData} from 'formdata-polyfill/esm.min.js';

	addEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;

	removeEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;

export type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>;

 * This Fetch API interface allows you to perform various actions on HTTP request and response headers.

 * These actions include retrieving, setting, adding to, and removing.

 * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.

 * You can add to this using methods like append() (see Examples.)

 * In all methods of this interface, header names are matched by case-insensitive byte sequence.

	append(name: string, value: string): void;

		callbackfn: (value: string, key: string, parent: Headers) => void,

	[Symbol.iterator](): IterableIterator<[string, string]>;

	 * Returns an iterator allowing to go through all key/value pairs contained in this object.

	entries(): IterableIterator<[string, string]>;

	 * Returns an iterator allowing to go through all keys of the key/value pairs contained in this object.

	 * Returns an iterator allowing to go through all values of the key/value pairs contained in this object.

	 * A BodyInit object or null to set request's body.

	 * A Headers object, an object literal, or an array of two-item arrays to set request's headers.

	 * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.

	 * An AbortSignal to set request's signal.

	 * A string whose value is a same-origin URL, "about:client", or the empty string, to set request’s referrer.

	 * A referrer policy to set request’s referrerPolicy.

	static redirect(url: string, status?: number): Response;

	static json(data: any, init?: ResponseInit): Response;

	constructor(message: string, type: string, systemError?: Record<string, unknown>);

export function isRedirect(code: number): boolean;

export default function fetch(url: RequestInfo, init?: RequestInit): Promise<Response>;

  "description": "A light-weight module that brings Fetch API to node.js",

    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"

    "coverage": "c8 report --reporter=text-lcov | coveralls",

    "url": "https://github.com/node-fetch/node-fetch.git"

    "url": "https://github.com/node-fetch/node-fetch/issues"

  "homepage": "https://github.com/node-fetch/node-fetch",

    "url": "https://opencollective.com/node-fetch"

    "abortcontroller-polyfill": "^1.7.1",

      "import/no-useless-path-segments": 0,

      "import/no-anonymous-default-export": 0,

      "unicorn/numeric-separators-style": 0,

      "unicorn/explicit-length-check": 0,

      "node/no-unsupported-features/es-syntax": 0,

      "@typescript-eslint/member-ordering": 0

	<p>A light-weight module that brings <a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API">Fetch API</a> to Node.js.</p>

	<b>Consider supporting us on our Open Collective:</b>

**You might be looking for the [v2 docs](https://github.com/node-fetch/node-fetch/tree/2.x#readme)**

- [Difference from client-side fetch](#difference-from-client-side-fetch)

- [Loading and configuring the module](#loading-and-configuring-the-module)

	- [Plain text or HTML](#plain-text-or-html)

	- [Post with form parameters](#post-with-form-parameters)

	- [Handling exceptions](#handling-exceptions)

	- [Handling client and server errors](#handling-client-and-server-errors)

	- [Accessing Headers and other Metadata](#accessing-headers-and-other-metadata)

	- [Extract Set-Cookie Header](#extract-set-cookie-header)

	- [Post data using a file](#post-data-using-a-file)

	- [Request cancellation with AbortSignal](#request-cancellation-with-abortsignal)

	- [fetch(url[, options])](#fetchurl-options)

		- [Custom highWaterMark](#custom-highwatermark)

		- [Insecure HTTP Parser](#insecure-http-parser)

		- [new Request(input[, options])](#new-requestinput-options)

		- [new Response([body[, options]])](#new-responsebody-options)

		- [response.redirected](#responseredirected)

		- [new Headers([init])](#new-headersinit)

		- [body.arrayBuffer()](#bodyarraybuffer)

	- [Class: FetchError](#class-fetcherror)

	- [Class: AbortError](#class-aborterror)

Instead of implementing `XMLHttpRequest` in Node.js to run browser-specific [Fetch polyfill](https://github.com/github/fetch), why not go from native `http` to `fetch` API directly? Hence, `node-fetch`, minimal code for a `window.fetch` compatible API on Node.js runtime.

See Jason Miller's [isomorphic-unfetch](https://www.npmjs.com/package/isomorphic-unfetch) or Leonardo Quixada's [cross-fetch](https://github.com/lquixada/cross-fetch) for isomorphic usage (exports `node-fetch` for server-side, `whatwg-fetch` for client-side).

- Stay consistent with `window.fetch` API.

- Make conscious trade-off when following [WHATWG fetch spec][whatwg-fetch] and [stream spec](https://streams.spec.whatwg.org/) implementation details, document known differences.

- Use native promise and async functions.

- Use native Node streams for body, on both request and response.

- Decode content encoding (gzip/deflate/brotli) properly, and convert string output (such as `res.text()` and `res.json()`) to UTF-8 automatically.

- Useful extensions such as redirect limit, response size limit, [explicit errors][error-handling.md] for troubleshooting.

- If you happen to use a missing feature that `window.fetch` offers, feel free to open an issue.

		super(`HTTP Error Response: ${response.status} ${response.statusText}`, ...args);

		super(`HTTP Error Response: ${response.status} ${response.statusText}`);

		// response.status >= 200 && response.status < 300

const response = await fetch('https://httpbin.org/status/400');

	const errorBody = await error.response.text();

	console.error(`Error body: ${errorBody}`);

Cookies are not stored by default. However, cookies can be extracted and passed by manipulating request and response headers. See [Extract Set-Cookie Header](#extract-set-cookie-header) for details.

The "Node.js way" is to use streams when possible. You can pipe `res.body` to another stream. This example uses [stream.pipeline](https://nodejs.org/api/stream.html#stream_stream_pipeline_streams_callback) to attach stream error handlers and wait for the download to complete.

import {createWriteStream} from 'node:fs';

const streamPipeline = promisify(pipeline);

const response = await fetch('https://github.githubassets.com/images/modules/logos_page/Octocat.png');

if (!response.ok) throw new Error(`unexpected response ${response.statusText}`);

await streamPipeline(response.body, createWriteStream('./octocat.png'));

In Node.js 14 you can also use async iterators to read `body`; however, be careful to catch

errors -- the longer a response runs, the more likely it is to encounter an error.

const response = await fetch('https://httpbin.org/stream/3');

	for await (const chunk of response.body) {

		console.dir(JSON.parse(chunk.toString()));

In Node.js 12 you can also use async iterators to read `body`; however, async iterators with streams

did not mature until Node.js 14, so you need to do some extra work to ensure you handle errors

directly from the stream and wait on it response to fully close.

	return new Promise((resolve, reject) => {

	const response = await fetch('https://httpbin.org/stream/3');

const blob = fileFromSync('./input.txt', mimetype)

const response = await fetch(url, { method: 'POST', body: blob })

node-fetch comes with a spec-compliant [FormData] implementations for posting

import fetch, { FormData, File, fileFrom } from 'node-fetch'

const httpbin = 'https://httpbin.org/post'

const binary = new Uint8Array([ 97, 98, 99 ])

const abc = new File([binary], 'abc.txt', { type: 'text/plain' })

formData.set('greeting', 'Hello, world!')

formData.set('file-upload', abc, 'new name.txt')

const response = await fetch(httpbin, { method: 'POST', body: formData })

If you for some reason need to post a stream coming from any arbitrary place,

then you can append a [Blob] or a [File] look-a-like item.

1. A `Symbol.toStringTag` getter or property that is either `Blob` or `File`

3. And either a `stream()` method or a `arrayBuffer()` method that returns a ArrayBuffer.

The `stream()` must return any async iterable object as long as it yields Uint8Array (or Buffer)

so Node.Readable streams and whatwg streams works just fine.

		return new Uint8Array([97, 98, 99]).buffer

### Request cancellation with AbortSignal

You may cancel requests with `AbortController`. A suggested implementation is [`abort-controller`](https://www.npmjs.com/package/abort-controller).

An example of timing out a request after 150ms could be achieved as the following:

import fetch, { AbortError } from 'node-fetch';

// AbortController was added in node v14.17.0 globally

const AbortController = globalThis.AbortController || await import('abort-controller')

const controller = new AbortController();

	const response = await fetch('https://example.com', {signal: controller.signal});

See [test cases](https://github.com/node-fetch/node-fetch/blob/master/test/) for more examples.

- `url` A string representing the URL for fetching

- `options` [Options](#fetch-options) for the HTTP(S) request

- Returns: <code>Promise&lt;[Response](#class-response)&gt;</code>

 * Response class provides content decoding

import Body, {clone, extractContentType} from './body.js';

import {isRedirect} from './utils/is-redirect.js';

const INTERNALS = Symbol('Response internals');

 * Ref: https://fetch.spec.whatwg.org/#response-class

 * @param   Stream  body  Readable stream

 * @param   Object  opts  Response options

export default class Response extends Body {

	constructor(body = null, options = {}) {

		// eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition

		const status = options.status != null ? options.status : 200;

		const headers = new Headers(options.headers);

		if (body !== null && !headers.has('Content-Type')) {

			const contentType = extractContentType(body, this);

				headers.append('Content-Type', contentType);

	 * Convenience property representing if the request ended normally

		return this[INTERNALS].status >= 200 && this[INTERNALS].status < 300;

		return new Response(clone(this, this.highWaterMark), {

	static json(data = undefined, init = {}) {

			throw new TypeError('data is not JSON serializable');

		const headers = new Headers(init && init.headers);

			headers.set('content-type', 'application/json');

Object.defineProperties(Response.prototype, {

		{
		"name": "node-fetch",
		"version": "3.2.10",
		"version": "3.3.0",
		"description": "A light-weight module that brings Fetch API to node.js",
		@@ -5,0 +5,0 @@ "main": "./src/index.js",

		@@ -272,4 +272,4 @@ <div align="center">
		class HTTPResponseError extends Error {
		constructor(response, ...args) {
		super(`HTTP Error Response: ${response.status} ${response.statusText}`, ...args);
		constructor(response) {
		super(`HTTP Error Response: ${response.status} ${response.statusText}`);
		this.response = response;
		@@ -404,3 +404,3 @@ }
		```js
		import fetch {
		import fetch, {
		Blob,
		@@ -407,0 +407,0 @@ blobFrom,

		@@ -127,2 +127,21 @@ /**

		static json(data = undefined, init = {}) {
		const body = JSON.stringify(data);

		if (body === undefined) {
		throw new TypeError('data is not JSON serializable');
		}

		const headers = new Headers(init && init.headers);

		if (!headers.has('content-type')) {
		headers.set('content-type', 'application/json');
		}

		return new Response(body, {
		...init,
		headers
		});
		}

		get [Symbol.toStringTag]() {
		@@ -129,0 +148,0 @@ return 'Response';

		@@ -199,2 +199,3 @@ /// <reference types="node" />
		static redirect(url: string, status?: number): Response;
		static json(data: any, init?: ResponseInit): Response;
		}
		@@ -201,0 +202,0 @@

Improved metrics