Huge thanks to for sponsoring me!

> Simplified HTTP requests [![Build Status: Linux](]( [![Coverage Status](]( [![Downloads](]( [![Install size](]( Got is a human-friendly and powerful HTTP request library. It was created because the popular [`request`]( package is bloated: [![Install size](]( Got is for Node.js. For browsers, we recommend [Ky]( ## Highlights - [Promise & stream API](#api) - [Request cancelation](#aborting-the-request) - [RFC compliant caching](#cache-adapters) - [Follows redirects](#followredirect) - [Retries on failure](#retry) - [Progress events](#onuploadprogress-progress) - [Handles gzip/deflate](#decompress) - [Timeout handling](#timeout) - [Errors with metadata](#errors) - [JSON mode](#json) - [WHATWG URL support](#url) - [Hooks]( - [Instances with custom defaults](#instances) - [Composable]( - [Electron support](#useelectronnet) - [Used by ~2000 packages and ~500K repos]( - Actively maintained [See how Got compares to other HTTP libraries](#comparison) ## Install ``` $ npm install got ``` ## Usage ```js const got = require('got'); (async () => { try { const response = await got(''); console.log(response.body); //=> ' ...' } catch (error) { console.log(error.response.body); //=> 'Internal server error ...' } })(); ``` ###### Streams ```js const fs = require('fs'); const got = require('got');'').pipe(fs.createWriteStream('index.html')); // For POST, PUT, and PATCH methods `` returns a `stream.Writable` fs.createReadStream('index.html').pipe('')); ``` ### API It's a `GET` request by default, but can be changed by using different methods or in the `options`. #### got(url, [options]) Returns a Promise for a [`response` object](#response) or a [stream](#streams-1) if `` is set to true. ##### url Type: `string` `Object` The URL to request, as a string, a [`https.request` options object](, or a [WHATWG `URL`]( Properties from `options` will override properties in the parsed `url`. If no protocol is specified, it will default to `https`. ##### options Type: `Object` Any of the [`https.request`]( options. ###### baseUrl Type: `string` `Object` When specified, `url` will be prepended by `baseUrl`.
If you specify an absolute URL, it will skip the `baseUrl`. Very useful when used with `got.extend()` to create niche-specific Got instances. Can be a string or a [WHATWG `URL`]( Slash at the end of `baseUrl` and at the beginning of the `url` argument is optional: ```js await got('hello', {baseUrl: ''}); //=> '' await got('/hello', {baseUrl: ''}); //=> '' await got('/hello', {baseUrl: ''}); //=> '' ``` ###### headers Type: `Object`
Default: `{}` Request headers. Existing headers will be overwritten. Headers set to `null` will be omitted. ###### stream Type: `boolean`
Default: `false` Returns a `Stream` instead of a `Promise`. This is equivalent to calling `, [options])`. ###### body Type: `string` `Buffer` `stream.Readable` [`form-data` instance]( *If you provide this option, `` will be read-only.* The body that will be sent with a `POST` request. If present in `options` and `options.method` is not set, `options.method` will be set to `POST`. The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / `fs.createReadStream` instance / [`form-data` instance](, and `content-length` and `transfer-encoding` are not manually set in `options.headers`. ###### cookieJar Type: [`tough.CookieJar` instance]( Cookie support. You don't have to care about parsing or how to store them. [Example.](#cookies) **Note:** `options.headers.cookie` will be overridden. ###### encoding Type: `string` `null`
Default: `'utf8'` [Encoding]( to be used on `setEncoding` of the response data. If `null`, the body is returned as a [`Buffer`]( (binary data). ###### form Type: `boolean`
Default: `false` *If you provide this option, `` will be read-only.* If set to `true` and `Content-Type` header is not set, it will be set to `application/x-www-form-urlencoded`. `body` must be a plain object. It will be converted to a query string using [`(new URLSearchParams(object)).toString()`]( ###### json Type: `boolean`
Default: `false` *If you use ``, this option will be ignored.* If set to `true` and `Content-Type` header is not set, it will be set to `application/json`. Parse response body with `JSON.parse` and set `accept` header to `application/json`. If used in conjunction with the `form` option, the `body` will the stringified as querystring and the response parsed as JSON. `body` must be a plain object or array and will be stringified. ###### query Type: `string` `Object` [`URLSearchParams`]( Query string that will be added to the request URL. This will override the query string in `url`. If you need to pass in an array, you can do it using a `URLSearchParams` instance: ```js const got = require('got'); const query = new URLSearchParams([['key', 'a'], ['key', 'b']]); got('', {query}); console.log(query.toString()); //=> 'key=a&key=b' ``` And if you need a different array format, you could use the [`query-string`]( package: ```js const got = require('got'); const queryString = require('query-string'); const query = queryString.stringify({key: ['a', 'b']}, {arrayFormat: 'bracket'}); got('', {query}); console.log(query); //=> 'key[]=a&key[]=b' ``` ###### timeout Type: `number` `Object` Milliseconds to wait for the server to end the response before aborting the request with [`got.TimeoutError`](#gottimeouterror) error (a.k.a. `request` property). By default, there's no timeout. This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle: - `lookup` starts when a socket is assigned and ends when the hostname has been resolved. Does not apply when using a Unix domain socket. - `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected. - `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only). - `socket` starts when the socket is connected. See [request.setTimeout]( - `response` starts when the request has been written to the socket and ends when the response headers are received. - `send` starts when the socket is connected and ends with the request has been written to the socket. - `request` starts when the request is initiated and ends when the response's end event fires. ###### retry Type: `number` `Object`
Default: - retries: `2` - methods: `GET` `PUT` `HEAD` `DELETE` `OPTIONS` `TRACE` - statusCodes: [`408`]( [`413`]( [`429`]( [`500`]( [`502`]( [`503`]( [`504`]( - maxRetryAfter: `undefined` An object representing `retries`, `methods`, `statusCodes` and `maxRetryAfter` fields for the time until retry, allowed methods, allowed status codes and maximum [`Retry-After`]( time. If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
If [`Retry-After`]( header is greater than `maxRetryAfter`, it will cancel the request. Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 0). The `retries` property can be a `number` or a `function` with `retry` and `error` arguments. The function must return a delay in milliseconds (`0` return value cancels retry). **Note:** It retries only on the specified methods, status codes, and on these network errors: - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached. - `ECONNRESET`: Connection was forcibly closed by a peer. - `EADDRINUSE`: Could not bind to any free port. - `ECONNREFUSED`: Connection was refused by the server. - `EPIPE`: The remote side of the stream being written has been closed. ###### followRedirect Type: `boolean`
Default: `true` Defines if redirect responses should be followed automatically. Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`. This is in accordance with [the spec]( ###### decompress Type: `boolean`
Default: `true` Decompress the response automatically. This will set the `accept-encoding` header to `gzip, deflate` unless you set it yourself. If this is disabled, a compressed response is returned as a `Buffer`. This may be useful if you want to handle decompression yourself or stream the raw compressed data. ###### cache Type: `Object`
Default: `false` [Cache adapter instance](#cache-adapters) for storing cached data. ###### request Type: `Function`
Default: `http.request` `https.request` *(depending on the protocol)* Custom request function. The main purpose of this is to [support HTTP2 using a wrapper](#experimental-http2-support). ###### useElectronNet Type: `boolean`
Default: `false` When used in Electron, Got will use [``]( instead of the Node.js `http` module. According to the Electron docs, it should be fully compatible, but it's not entirely. See [#443]( and [#461]( ###### throwHttpErrors Type: `boolean`
Default: `true` Determines if a `got.HTTPError` is thrown for error responses (non-2xx status codes). If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing. This may be useful if you are checking for resource availability and are expecting error responses. ###### agent Same as the [`agent` option]( for `http.request`, but with an extra feature: If you require different agents for different protocols, you can pass a map of agents to the `agent` option. This is necessary because a request to one protocol might redirect to another. In such a scenario, Got will switch over to the right protocol agent for you. ```js const got = require('got'); const HttpAgent = require('agentkeepalive'); const {HttpsAgent} = HttpAgent; got('', { agent: { http: new HttpAgent(), https: new HttpsAgent() } }); ``` ###### hooks Type: `Object` Hooks allow modifications during the request lifecycle. Hook functions may be async and are run serially. ###### hooks.beforeRequest Type: `Function[]`
Default: `[]` Called with [normalized](source/normalize-arguments.js) [request options](#options). Got will make no further changes to the request before it is sent. This is especially useful in conjunction with [`got.extend()`](#instances) and [`got.create()`]( when you want to create an API client that, for example, uses HMAC-signing. See the [AWS section](#aws) for an example. **Note**: If you modify the `body` you will need to modify the `content-length` header too, because it has already been computed and assigned. ###### hooks.beforeRedirect Type: `Function[]`
Default: `[]` Called with [normalized](source/normalize-arguments.js) [request options](#options). Got will make no further changes to the request. This is especially useful when you want to avoid dead sites. Example: ```js const got = require('got'); got('', { hooks: { beforeRedirect: [ options => { if (options.hostname === 'deadSite') { options.hostname = 'fallbackSite'; } } ] } }); ``` ###### hooks.beforeRetry Type: `Function[]`
Default: `[]` Called with [normalized](source/normalize-arguments.js) [request options](#options), the error and the retry count. Got will make no further changes to the request. This is especially useful when some extra work is required before the next try. Example: ```js const got = require('got'); got('', { hooks: { beforeRetry: [ (options, error, retryCount) => { if (error.statusCode === 413) { // Payload too large options.body = getNewBody(); } } ] } }); ``` ###### hooks.afterResponse Type: `Function[]`
Default: `[]` Called with [response object](#response) and a retry function. Each function should return the response. This is especially useful when you want to refresh an access token. Example: ```js const got = require('got'); const instance = got.extend({ hooks: { afterResponse: [ (response, retryWithMergedOptions) => { if (response.statusCode === 401) { // Unauthorized const updatedOptions = { headers: { token: getNewToken() // Refresh the access token } }; // Save for further requests instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions); // Make a new retry return retryWithMergedOptions(updatedOptions); } // No changes otherwise return response; } ] }, mutableDefaults: true }); ``` #### Response The response object will typically be a [Node.js HTTP response stream](, however, if returned from the cache it will be a [response-like object]( which behaves in the same way. ##### body Type: `string` `Object` *(depending on `options.json`)* The result of the request. ##### url Type: `string` The request URL or the final URL after redirects. ##### requestUrl Type: `string` The original request URL. ##### timings Type: `Object` The object contains the following properties: - `start` - Time when the request started. - `socket` - Time when a socket was assigned to the request. - `lookup` - Time when the DNS lookup finished. - `connect` - Time when the socket successfully connected. - `upload` - Time when the request finished uploading. - `response` - Time when the request fired the `response` event. - `end` - Time when the response fired the `end` event. - `error` - Time when the request fired the `error` event. - `phases` - `wait` - `timings.socket - timings.start` - `dns` - `timings.lookup - timings.socket` - `tcp` - `timings.connect - timings.lookup` - `request` - `timings.upload - timings.connect` - `firstByte` - `timings.response - timings.upload` - `download` - `timings.end - timings.response` - `total` - `timings.end - timings.start` or `timings.error - timings.start` **Note**: The time is a `number` representing the milliseconds elapsed since the UNIX epoch. ##### fromCache Type: `boolean` Whether the response was retrieved from the cache. ##### redirectUrls Type: `Array` The redirect URLs. ##### retryCount Type: `number` The number of times the request was retried. #### Streams **Note**: Progress events, redirect events and request/response events can also be used with promises. ####, [options]) Sets `` to `true`. Returns a [duplex stream]( with additional events: ##### .on('request', request) `request` event to get the request object of the request. **Tip**: You can use `request` event to abort request: ```js'') .on('request', request => setTimeout(() => request.abort(), 50)); ``` ##### .on('response', response) The `response` event to get the response object of the final request. ##### .on('redirect', response, nextOptions) The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location. ##### .on('uploadProgress', progress) ##### .on('downloadProgress', progress) Progress events for uploading (sending a request) and downloading (receiving a response). The `progress` argument is an object like: ```js { percent: 0.1, transferred: 1024, total: 10240 } ``` If it's not possible to retrieve the body size (can happen when streaming), `total` will be `null`. ```js (async () => { const response = await got('') .on('downloadProgress', progress => { // Report download progress }) .on('uploadProgress', progress => { // Report upload progress }); console.log(response); })(); ``` ##### .on('error', error, body, response) The `error` event emitted in case of a protocol error (like `ENOTFOUND` etc.) or status error (4xx or 5xx). The second argument is the body of the server response in case of status error. The third argument is a response object. #### got.get(url, [options]) ####, [options]) #### got.put(url, [options]) #### got.patch(url, [options]) #### got.head(url, [options]) #### got.delete(url, [options]) Sets `options.method` to the method name and makes a request. ### Instances #### got.extend([options]) Configure a new `got` instance with default `options`. The `options` are merged with the parent instance's `defaults.options` using [`got.mergeOptions`](#gotmergeoptionsparentoptions-newoptions). You can access the resolved options with the `.defaults` property on the instance. ```js const client = got.extend({ baseUrl: '', headers: { 'x-unicorn': 'rainbow' } }); client.get('/demo'); /* HTTP Request => * GET /demo HTTP/1.1 * Host: * x-unicorn: rainbow */ ``` ```js (async () => { const client = got.extend({ baseUrl: '', headers: { 'x-foo': 'bar' } }); const {headers} = (await client.get('/headers', {json: true})).body; //=> headers['x-foo'] === 'bar' const jsonClient = client.extend({ json: true, headers: { 'x-baz': 'qux' } }); const {headers: headers2} = (await jsonClient.get('/headers')).body; //=> headers2['x-foo'] === 'bar' //=> headers2['x-baz'] === 'qux' })(); ``` *Need more control over the behavior of Got? Check out the [`got.create()`](* #### got.mergeOptions(parentOptions, newOptions) Extends parent options. Avoid using [object spread]( as it doesn't work recursively: ```js const a = {headers: {cat: 'meow', wolf: ['bark', 'wrrr']}}; const b = {headers: {cow: 'moo', wolf: ['auuu']}}; {...a, ...b} // => {headers: {cow: 'moo', wolf: ['auuu']}} got.mergeOptions(a, b) // => {headers: {cat: 'meow', cow: 'moo', wolf: ['auuu']}} ``` Options are deeply merged to a new object. The value of each key is determined as follows: - If the new property is set to `undefined`, it keeps the old one. - If the parent property is an instance of `URL` and the new value is a `string` or `URL`, a new URL instance is created: [`new URL(new, parent)`]( - If the new property is a plain `Object`: - If the parent property is a plain `Object` too, both values are merged recursively into a new `Object`. - Otherwise, only the new value is deeply cloned. - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property. - Otherwise, the new value is assigned to the key. #### got.defaults Type: `Object` The default Got options. ## Errors Each error contains (if available) `body`, `statusCode`, `statusMessage`, `host`, `hostname`, `method`, `path`, `protocol` and `url` properties to make debugging easier. In Promise mode, the `response` is attached to the error. #### got.CacheError When a cache method fails, for example, if the database goes down or there's a filesystem error. #### got.RequestError When a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`. #### got.ReadError When reading from response stream fails. #### got.ParseError When `json` option is enabled, server response code is 2xx, and `JSON.parse` fails. #### got.HTTPError When the server response code is not 2xx. Includes `statusCode`, `statusMessage`, and `redirectUrls` properties. #### got.MaxRedirectsError When the server redirects you more than ten times. Includes a `redirectUrls` property, which is an array of the URLs Got was redirected to before giving up. #### got.UnsupportedProtocolError When given an unsupported protocol. #### got.CancelError When the request is aborted with `.cancel()`. #### got.TimeoutError When the request is aborted due to a [timeout](#timeout) ## Aborting the request The promise returned by Got has a [`.cancel()`]( method which when called, aborts the request. ```js (async () => { const request = got(url, options); // … // In another part of the code if (something) { request.cancel(); } // … try { await request; } catch (error) { if (request.isCanceled) { // Or `error instanceof got.CancelError` // Handle cancelation } // Handle other errors } })(); ``` ## Cache Got implements [RFC 7234]( compliant HTTP caching which works out of the box in-memory and is easily pluggable with a wide range of storage adapters. Fresh cache entries are served directly from the cache, and stale cache entries are revalidated with `If-None-Match`/`If-Modified-Since` headers. You can read more about the underlying cache behavior in the [`cacheable-request` documentation]( You can use the JavaScript `Map` type as an in-memory cache: ```js const got = require('got'); const map = new Map(); (async () => { let response = await got('', {cache: map}); console.log(response.fromCache); //=> false response = await got('', {cache: map}); console.log(response.fromCache); //=> true })(); ``` Got uses [Keyv]( internally to support a wide range of storage adapters. For something more scalable you could use an [official Keyv storage adapter]( ``` $ npm install @keyv/redis ``` ```js const got = require('got'); const KeyvRedis = require('@keyv/redis'); const redis = new KeyvRedis('redis://user:pass@localhost:6379'); got('', {cache: redis}); ``` Got supports anything that follows the Map API, so it's easy to write your own storage adapter or use a third-party solution. For example, the following are all valid storage adapters: ```js const storageAdapter = new Map(); // Or const storageAdapter = require('./my-storage-adapter'); // Or const QuickLRU = require('quick-lru'); const storageAdapter = new QuickLRU({maxSize: 1000}); got('', {cache: storageAdapter}); ``` View the [Keyv docs]( for more information on how to use storage adapters. ## Proxies You can use the [`tunnel`]( package with the `agent` option to work with proxies: ```js const got = require('got'); const tunnel = require('tunnel'); got('', { agent: tunnel.httpOverHttp({ proxy: { host: 'localhost' } }) }); ``` Check out [`global-tunnel`]( if you want to configure proxy support for all HTTP/HTTPS traffic in your app. ## Cookies You can use the [`tough-cookie`]( package: ```js const got = require('got'); const {CookieJar} = require('tough-cookie'); const cookieJar = new CookieJar(); cookieJar.setCookie('foo=bar', ''); got('', {cookieJar}); ``` ## Form data You can use the [`form-data`]( package to create POST request with form data: ```js const fs = require('fs'); const got = require('got'); const FormData = require('form-data'); const form = new FormData(); form.append('my_file', fs.createReadStream('/foo/bar.jpg'));'', { body: form }); ``` ## OAuth You can use the [`oauth-1.0a`]( package to create a signed OAuth request: ```js const got = require('got'); const crypto = require('crypto'); const OAuth = require('oauth-1.0a'); const oauth = OAuth({ consumer: { key: process.env.CONSUMER_KEY, secret: process.env.CONSUMER_SECRET }, signature_method: 'HMAC-SHA1', hash_function: (baseString, key) => crypto.createHmac('sha1', key).update(baseString).digest('base64') }); const token = { key: process.env.ACCESS_TOKEN, secret: process.env.ACCESS_TOKEN_SECRET }; const url = ''; got(url, { headers: oauth.toHeader(oauth.authorize({url, method: 'GET'}, token)), json: true }); ``` ## Unix Domain Sockets Requests can also be sent via [unix domain sockets]( Use the following URL scheme: `PROTOCOL://unix:SOCKET:PATH`. - `PROTOCOL` - `http` or `https` *(optional)* - `SOCKET` - Absolute path to a unix domain socket, for example: `/var/run/docker.sock` - `PATH` - Request path, for example: `/v2/keys` ```js got('http://unix:/var/run/docker.sock:/containers/json'); // Or without protocol (HTTP by default) got('unix:/var/run/docker.sock:/containers/json'); ``` ## AWS Requests to AWS services need to have their headers signed. This can be accomplished by using the [`aws4`]( package. This is an example for querying an ["API Gateway"]( with a signed request. ```js const AWS = require('aws-sdk'); const aws4 = require('aws4'); const got = require('got'); const chain = new AWS.CredentialProviderChain(); // Create a Got instance to use relative paths and signed requests const awsClient = got.extend({ baseUrl: '', hooks: { beforeRequest: [ async options => { const credentials = await chain.resolvePromise(); aws4.sign(options, credentials); } ] } }); const response = await awsClient('endpoint/path', { // Request-specific options }); ``` ## Testing You can test your requests by using the [`nock`]( package to mock an endpoint: ```js const got = require('got'); const nock = require('nock'); nock('') .get('/') .reply(200, 'Hello world!'); (async () => { const response = await got(''); console.log(response.body); //=> 'Hello world!' })(); ``` If you need real integration tests you can use [`create-test-server`]( ```js const got = require('got'); const createTestServer = require('create-test-server'); (async () => { const server = await createTestServer(); server.get('/', 'Hello world!'); const response = await got(server.url); console.log(response.body); //=> 'Hello world!' await server.close(); })(); ``` ## Tips ### User Agent It's a good idea to set the `'user-agent'` header so the provider can more easily see how their resource is used. By default, it's the URL to this repo. You can omit this header by setting it to `null`. ```js const got = require('got'); const pkg = require('./package.json'); got('', { headers: { 'user-agent': `my-package/${pkg.version} (` } }); got('', { headers: { 'user-agent': null } }); ``` ### 304 Responses Bear in mind; if you send an `if-modified-since` header and receive a `304 Not Modified` response, the body will be empty. It's your responsibility to cache and retrieve the body contents. ### Custom endpoints Use `got.extend()` to make it nicer to work with REST APIs. Especially if you use the `baseUrl` option. **Note:** Not to be confused with [`got.create()`](, which has no defaults. ```js const got = require('got'); const pkg = require('./package.json'); const custom = got.extend({ baseUrl: '', json: true, headers: { 'user-agent': `my-package/${pkg.version} (` } }); // Use `custom` exactly how you use `got` (async () => { const list = await custom('/v1/users/list'); })(); ``` *Need to merge some instances into a single one? Check out [`got.mergeInstances()`](* ### Experimental HTTP2 support Got provides an experimental support for HTTP2 using the [`http2-wrapper`]( package: ```js const got = require('got'); const {request} = require('http2-wrapper'); const h2got = got.extend({request}); (async () => { const {body} = await h2got(''); console.log(body); })(); ``` ## Comparison | | `got` | `request` | `node-fetch` | `axios` | |-----------------------|:------------:|:------------:|:------------:|:------------:| | HTTP/2 support | ❔ | ✖ | ✖ | ✖ | | Browser support | ✖ | ✖ | ✔* | ✔ | | Electron support | ✔ | ✖ | ✖ | ✖ | | Promise API | ✔ | ✔ | ✔ | ✔ | | Stream API | ✔ | ✔ | Node.js only | ✖ | | Request cancelation | ✔ | ✖ | ✖ | ✔ | | RFC compliant caching | ✔ | ✖ | ✖ | ✖ | | Cookies (out-of-box) | ✔ | ✔ | ✖ | ✖ | | Follows redirects | ✔ | ✔ | ✔ | ✔ | | Retries on failure | ✔ | ✖ | ✖ | ✖ | | Progress events | ✔ | ✖ | ✖ | Browser only | | Handles gzip/deflate | ✔ | ✔ | ✔ | ✔ | | Advanced timeouts | ✔ | ✖ | ✖ | ✖ | | Timings | ✔ | ✔ | ✖ | ✖ | | Errors with metadata | ✔ | ✖ | ✖ | ✔ | | JSON mode | ✔ | ✔ | ✖ | ✔ | | Custom defaults | ✔ | ✔ | ✖ | ✔ | | Composable | ✔ | ✖ | ✖ | ✖ | | Hooks | ✔ | ✖ | ✖ | ✔ | | Issues open | ![][gio] | ![][rio] | ![][nio] | ![][aio] | | Issues closed | ![][gic] | ![][ric] | ![][nic] | ![][aic] | | Downloads | ![][gd] | ![][rd] | ![][nd] | ![][ad] | | Coverage | ![][gc] | ![][rc] | ![][nc] | ![][ac] | | Build | ![][gb] | ![][rb] | ![][nb] | ![][ab] | | Bugs | ![][gbg] | ![][rbg] | ![][nbg] | ![][abg] | | Dependents | ![][gdp] | ![][rdp] | ![][ndp] | ![][adp] | | Install size | ![][gis] | ![][ris] | ![][nis] | ![][ais] | \* It's almost API compatible with the browser `fetch` API.
❔ Experimental support. [gio]: [rio]: [nio]: [aio]: [gic]: [ric]: [nic]: [aic]: [gd]: [rd]: [nd]: [ad]: [gc]: [rc]: [nc]: [ac]: [gb]: [rb]: [nb]: [ab]: [gbg]: [rbg]: [nbg]: [abg]: [gdp]: [rdp]: [ndp]: [adp]: [gis]: [ris]: [nis]: [ais]: ## Related - [gh-got]( - Got convenience wrapper to interact with the GitHub API - [gl-got]( - Got convenience wrapper to interact with the GitLab API - [travis-got]( - Got convenience wrapper to interact with the Travis API - [graphql-got]( - Got convenience wrapper to interact with GraphQL - [GotQL]( - Got convenience wrapper to interact with GraphQL using JSON-parsed queries instead of strings ## Maintainers [![Sindre Sorhus](]( | [![Vsevolod Strukchinsky](]( | [![Alexander Tesfamichael](]( | [![Luke Childs](]( | [![Szymon Marczak](]( | [![Brandon Smith](]( ---|---|---|---|---|--- [Sindre Sorhus]( | [Vsevolod Strukchinsky]( | [Alexander Tesfamichael]( | [Luke Childs]( | [Szymon Marczak]( | [Brandon Smith]( ## License MIT