Registry / http-networking / http2-proxy

http2-proxy

JSON →
library5.0.53jsnpmunverified

http2-proxy is a robust Node.js library engineered to serve as a high-performance proxy for both HTTP/2 and HTTP/1.1 traffic, including support for WebSocket connections. Currently at version 5.0.53, the library maintains an active development status, though its major version release cadence appears irregular, with a significant jump from 1.x to 5.x. A core differentiator is its adherence to HTTP specifications, automatically managing critical headers such as hop-by-hop, connection, via, and forward. It is designed to be fully compatible with Node.js's async/await paradigm, with callback-based usage being an optional but discouraged alternative. A notable feature is its resilience during 503 errors, where it's safe to assume no data was read or written, enabling reliable request retries for all methods, including non-idempotent ones. Users are responsible for implementing their own final and error handlers, as the library does not perform automatic cleanup of errored responses, which provides flexibility for custom retry mechanisms. It requires Node.js v10.0.0 or higher to function correctly. The package also integrates seamlessly with common middleware frameworks like Connect and security libraries like Helmet.

npm install http2-proxy
INSTALL
IMPORT
SIG · HTTP2-PROXY
H
http2-proxy
http-networkingjavascriptv5.0.53
Install
Import
Disk
Pass rate
0/ 6
Env Coverage0 / 6
glibc
1822
musl
1822
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 18226 runs
build_error
glibc
node 18226 runs
build_error
Code
Verified usage

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

proxy
import proxy from 'http2-proxy'
const proxy = require('http2-proxy')
Since v5.x, the package is primarily ESM-first. While CommonJS `require` might work for the default export, `import` is the recommended and safest approach for consistency across Node.js environments.
proxy.web
import proxy from 'http2-proxy'; proxy.web(req, res, options, handler)
import { web } from 'http2-proxy'
`web` is a method of the default `proxy` export, not a direct named export from the package.
proxy.ws
import proxy from 'http2-proxy'; proxy.ws(req, socket, head, options, handler)
import { ws } from 'http2-proxy'
`ws` is a method of the default `proxy` export, not a direct named export from the package.

This code sets up an HTTP/2 server that also accepts HTTP/1.1 connections. It then proxies both HTTP and WebSocket requests to a specified target hostname and port, demonstrating error handling and optional request/response modification.

import http2 from 'http2'; import proxy from 'http2-proxy'; import finalhandler from 'finalhandler'; const port = 8000; const targetHostname = 'localhost'; const targetPort = 9001; // Ensure a backend server is running on this port for testing const defaultWebHandler = (err, req, res) => { if (err) { console.error('HTTP proxy error:', err.message); // Log error message for clarity if (!res.headersSent) { finalhandler(req, res)(err); } else { // If headers already sent, just end the response to prevent further errors res.end(); } } }; const defaultWsHandler = (err, req, socket, head) => { if (err) { console.error('WebSocket proxy error:', err.message); socket.destroy(); } }; const server = http2.createServer({ allowHTTP1: true }); server.on('request', (req, res) => { proxy.web(req, res, { hostname: targetHostname, port: targetPort, // Optional: Add custom headers to the request sent to the target onReq: (proxyReq, options) => { options.headers['x-forwarded-for'] = req.socket.remoteAddress; options.headers['x-custom-proxy-header'] = 'http2-proxy-example'; }, // Optional: Modify the response from the target before sending to client onRes: (req, res, proxyRes) => { res.setHeader('x-proxied-by', 'http2-proxy'); res.writeHead(proxyRes.statusCode, proxyRes.headers); proxyRes.pipe(res); } }, defaultWebHandler); }); server.on('upgrade', (req, socket, head) => { proxy.ws(req, socket, head, { hostname: targetHostname, port: targetPort }, defaultWsHandler); }); server.listen(port, () => { console.log(`Proxy server listening on port ${port}`); console.log(`Proxying HTTP and WebSocket requests to ${targetHostname}:${targetPort}`); });
Debug
Known issues
gotchahttp2-proxy requires Node.js v10.0.0 or higher. Running on older Node.js versions may lead to unexpected behavior or runtime errors due to missing API features.
fix
Upgrade your Node.js environment to version 10.0.0 or newer.
affects: <10.0.0
breakingThe significant jump from v1.x to v5.x likely introduced breaking changes in the API and internal implementation. While specific changes are not detailed in the provided README excerpt, users upgrading from v1.x should review release notes for a comprehensive list of breaking changes.
fix
Consult the official GitHub repository's release notes or changelog for specific migration instructions when upgrading across major versions.
affects: >=2.0.0
gotchaErrored proxy responses are not automatically cleaned up. Users must implement explicit error handlers (like `finalhandler`) to prevent resource leaks and ensure proper client response, even for non-idempotent methods.
fix
Provide a callback function to `proxy.web` and `proxy.ws` that handles errors, typically using `finalhandler` or a custom error handling middleware, to gracefully close connections or send error responses.
affects: >=0.1.0
deprecatedWhile callback-based API usage is still supported, it is officially discouraged in favor of async/await patterns. Relying heavily on callbacks may lead to less readable or harder-to-maintain code.
fix
Refactor your proxy implementation to leverage Node.js's async/await syntax for better error handling and control flow.
affects: >=1.1.0
Errors
Common errors & fixes
TypeError: proxy.web is not a function
This error often occurs when attempting to use CommonJS `require` to import the library, and then trying to access `web` as a named export directly from the module. The package's primary export is a default object containing `web` and `ws` methods, especially in an ESM context.
fix
When using ESM, use `import proxy from 'http2-proxy';`. When using CommonJS, if ESM default export is not properly handled, try `const { default: proxy } = require('http2-proxy');` or ensure your `require` statement assigns the default export to `proxy`.
(node:XXXXX) UnhandledPromiseRejectionWarning: [error message]
Proxy operations (especially `onReq` or `onRes` hooks) might involve asynchronous code that throws an error or returns a rejected promise, which is not caught or awaited, leading to an unhandled rejection.
fix
Ensure all asynchronous operations within `onReq`, `onRes`, or other custom handlers are properly awaited using `await` or handled with `.catch()` clauses. Additionally, confirm that your `defaultWebHandler` and `defaultWsHandler` are robustly catching and processing any errors passed to them by the proxy functions.
Upgrade
Version history
5.0.53latest on npm
Audit
Dependencies

No dependency data recorded yet.

Agent activity
10 hits · last 30 days
node
10
Resources
http2-proxy — npm install http2-proxy · libregistry