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.

	constructor(input: RequestInfo, init?: RequestInit);

	constructor(input: URL | RequestInfo, init?: RequestInit);

	 * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.

	 * Returns request's HTTP method, which is "GET" by default.

	 * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.

	 * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.

	 * Returns the URL of request as a string.

	readonly referrerPolicy: ReferrerPolicy;

export class Response extends BodyMixin {

	constructor(body?: BodyInit | null, init?: ResponseInit);

	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>;

export default function fetch(url: 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.

const response = await fetch('https://httpbin.org/status/301', { redirect: 'manual' });

if (response.status === 301 || response.status === 302) {

	const locationURL = new URL(response.headers.get('location'), response.url);

	const response2 = await fetch(locationURL, { redirect: 'manual' });

An HTTP(S) request containing information about URL, method, headers, and the body. This class implements the [Body](#iface-body) interface.

Due to the nature of Node.js, the following properties are not implemented at this moment:

The following node-fetch extension properties are provided:

See [options](#fetch-options) for exact meaning of these extensions.

- `input` A string representing a URL, or another `Request` (which will be cloned)

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

Constructs a new `Request` object. The constructor is identical to that in the [browser](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).

In most cases, directly `fetch(url, options)` is simpler than creating a `Request` object.

An HTTP(S) response. This class implements the [Body](#iface-body) interface.

The following properties are not implemented in node-fetch at this moment:

- `body` A `String` or [`Readable` stream][node-readable]

- `options` A [`ResponseInit`][response-init] options dictionary

Constructs a new `Response` object. The constructor is identical to that in the [browser](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response).

Because Node.js does not implement service workers (for which this class was designed), one rarely has to construct a `Response` directly.

Convenience property representing if the request ended normally. Will evaluate to true if the response status was greater than or equal to 200 but smaller than 300.

Convenience property representing if the request has been redirected at least once. Will evaluate to true if the internal redirect counter is greater than 0.

Convenience property representing the response's type. node-fetch only supports `'default'` and `'error'` and does not make use of [filtered responses](https://fetch.spec.whatwg.org/#concept-filtered-response).

This class allows manipulating and iterating over a set of HTTP headers. All methods specified in the [Fetch Standard][whatwg-fetch] are implemented.

- `init` Optional argument to pre-fill the `Headers` object

Construct a new `Headers` object. `init` can be either `null`, a `Headers` object, an key-value map object or any iterable object.

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

		@@ -630,3 +630,3 @@ <div align="center">
		```js
		const fetch = require('node-fetch');
		import fetch from 'node-fetch';

		@@ -633,0 +633,0 @@ const response = await fetch('https://httpbin.org/status/301', { redirect: 'manual' });

		@@ -150,3 +150,3 @@ /// <reference types="node" />
		export class Request extends BodyMixin {
		constructor(input: RequestInfo, init?: RequestInit);
		constructor(input: URL \| RequestInfo, init?: RequestInit);

		@@ -220,2 +220,2 @@ /**
		export function isRedirect(code: number): boolean;
		export default function fetch(url: RequestInfo, init?: RequestInit): Promise<Response>;
		export default function fetch(url: URL \| RequestInfo, init?: RequestInit): Promise<Response>;

Improved metrics