Registry / http-networking / bent

bent

JSON →
library0.0.80jsnpmunverified

Bent is a small, functional, and async/await-based HTTP client designed for both Node.js and browsers. Currently stable at version 7.3.12, it provides a fluent API for making HTTP requests with a focus on type-driven configuration. Key differentiators include its remarkably small bundle size (especially for browsers, where it's built on `fetch` with no external dependencies), flexible option parsing (inferring method, format, status codes, and base URL from argument types), and explicit error handling for unacceptable response statuses. While mature, its release cadence is not high, indicating stability over rapid feature churn. It differs from alternatives by prioritizing a functional, curried API over object-oriented design and by requiring explicit declaration of accepted status codes, which helps prevent unexpected success conditions.

http-networkingweb-framework
npm install bent
github ↗package ↗
INSTALL
IMPORT
SIG · BENT
B
bent
http-networkingjavascriptv0.0.80
Install
—
Import
—
Disk
—
Pass rate
0/ 6
Env Coverage0 / 6
glibc
18–22
musl
18–22
Install & Compatibility
Where this runs
tested against v? · npm install
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
musl
node 18–226 runs
build_error
glibc
node 18–226 runs
build_error
Code
Verified usage

Verified import paths — ran on the pinned version, not inferred.

bent
✓ const bent = require('bent')
✗ import bent from 'bent'
Bent v7 is primarily a CommonJS module for Node.js. While bundlers can handle ESM imports for browser targets, attempting `import bent from 'bent'` in a pure Node.js ESM project will typically result in an error like `ERR_REQUIRE_ESM`.
getJSON
✓ const getJSON = bent('json', 'GET');
When using Bent, you first create a 'bent instance' with desired default options (like response format, method, base URL, accepted status codes) and then call that instance for specific requests.
bent
✓ import bent from 'bent'; // When used in browser via a bundler
✗ const bent = require('bent'); // For browser builds
For browser applications, Bent is typically bundled, and an ESM import `import bent from 'bent'` is common as bundlers will correctly resolve the browser-specific module entry point. `require` is not standard in browser environments.

Demonstrates creating different `bent` instances for GET (JSON) and POST (JSON) requests, and fetching binary data as a buffer, with error handling.

const bent = require('bent'); async function fetchData() { try { // Create a bent instance for GET requests expecting JSON and 200 OK const getJSON = bent('GET', 'json', 200); // Create a bent instance for POST requests expecting 201 Created and JSON input/output const postJSON = bent('POST', 'json', 201); console.log('Fetching public JSON data...'); const publicData = await getJSON('https://jsonplaceholder.typicode.com/todos/1'); console.log('Public Data:', publicData); console.log('\nPosting new data...'); const newData = { title: 'foo', body: 'bar', userId: 1 }; // Using a fake API endpoint that always returns 201 for POST const postResponse = await postJSON('https://jsonplaceholder.typicode.com/posts', newData); console.log('Post Response:', postResponse); // Example of fetching a buffer (e.g., an image, though this is a text file) const getBuffer = bent('GET', 'buffer', 200); console.log('\nFetching a text file as buffer...'); const buffer = await getBuffer('https://jsonplaceholder.typicode.com/todos/1'); // Fetching same data but as buffer console.log('Buffer content start:', buffer.toString().substring(0, 50), '...'); } catch (error) { console.error('An error occurred:', error.message); if (error.statusCode) { console.error('Status Code:', error.statusCode); } if (error.text) { const errorBody = await error.text(); console.error('Error Body:', errorBody); } } } fetchData();
Debug
Known issues
breakingBent requires explicit declaration of *all* acceptable status codes. If you provide any status codes, `200` must be explicitly included if you want it to be acceptable. By default, only `200` is acceptable unless overridden.
fix
Ensure all expected successful status codes, including `200`, are passed to the `bent` factory function, e.g., `bent(200, 201)`.
affects: >=7.0.0
gotchaWhen sending `form-urlencoded` data, Bent does not automatically encode the body or set the `Content-Type` header. You must manually encode the body (e.g., using `URLSearchParams` or `form-urlencoded` package) and set the `Content-Type` header to `application/x-www-form-urlencoded`.
fix
Use `const postForm = bent('POST', { 'Content-Type': 'application/x-www-form-urlencoded' }); await postForm(url, new URLSearchParams({ key: 'value' }).toString());`
affects: >=7.0.0
gotchaBent uses Node.js `Buffer` for binary data in Node.js environments and `ArrayBuffer` (or `ArrayBufferView` types like `UInt8Array`) in browser environments. Mixing these types or assuming `Buffer` is globally available in browsers will lead to errors.
fix
Always check the environment and use the appropriate binary type. In Node.js, `Buffer.from('data')`; in browser, `new TextEncoder().encode('data')` for `ArrayBufferView` or `new ArrayBuffer(...)`.
affects: >=7.0.0
gotchaBent v7 primarily ships as a CommonJS module for Node.js. Direct `import bent from 'bent'` statements in pure Node.js ESM projects will result in `ERR_REQUIRE_ESM` errors unless transpiled or configured via `type: 'module'` with appropriate `require` shims.
fix
In Node.js ESM projects, if a `bent` ESM build isn't available or preferred, use dynamic `import('bent').then(m => m.default || m)` or consider a CommonJS wrapper. For browser, bundling typically handles ESM imports correctly.
affects: >=7.0.0
Errors
Common errors & fixes
ERR_REQUIRE_ESM
Attempting to `import bent from 'bent'` in a Node.js project configured with `"type": "module"` in `package.json`.
fix
Change the import to `const bent = require('bent');` or use a dynamic import `const bent = await import('bent');` and then access `bent.default || bent` for the actual function.
Status code 404 not acceptable
The HTTP response had a status code (e.g., 404 Not Found) that was not explicitly listed as an acceptable status code when the `bent` instance was created.
fix
Modify your `bent` factory call to include all expected successful status codes, e.g., `bent(200, 201, 404)` if 404 is an expected, handled case.
Error: Response body is not JSON
The `bent` instance was configured with `'json'` as the response format, but the server responded with non-JSON content or an empty body.
fix
Ensure the server is sending `Content-Type: application/json` and valid JSON. If the content type varies, create `bent` instances that don't specify a response format (`bent()`) and use `response.json()` conditionally, or `bent('string')` for text responses.
Cannot read property 'buffer' of undefined
Trying to use `.buffer()` or `.json()` methods on the raw response object when the `bent` instance was *not* configured for a specific response type, and the method might not exist or be appropriate.
fix
If you need a specific format (like `buffer` or `json`), configure your `bent` instance with that format (e.g., `const getBuffer = bent('buffer');`). If not, handle the raw Node.js stream or use the `.arrayBuffer()`/`.text()`/`.json()` methods provided on the response object (matching Fetch API) after checking its type or status.
Upgrade
Version history
0.0.80latest on npm
Audit
Dependencies

No dependency data recorded yet.

Agent activity
16 hits · last 30 days
node
12
OpenAI (training)
1
Resources
githubhttps://github.com/mikeal/bent ↗
packagehttps://www.npmjs.com/package/bent ↗
bent — npm install bent · libregistry