apify/proxy-chain

import { Server } from 'proxy-chain';

const server = new Server({ port: 8000 });

await server.listen();
console.log(`Proxy server is listening on port ${server.port}`);

import { Server } from 'proxy-chain';

const server = new Server({
    // Port where the server will listen. By default 8000.
    port: 8000,

    // Optional host where the proxy server will listen.
    // If not specified, the sever listens on an unspecified IP address (0.0.0.0 in IPv4, :: in IPv6)
    // You can use this option to limit the access to the proxy server.
    host: 'localhost',

    // Enables verbose logging
    verbose: true,

    // Custom user-defined function to authenticate incoming proxy requests,
    // and optionally provide the URL to chained upstream proxy.
    // The function must return an object (or promise resolving to the object) with the following signature:
    // { requestAuthentication: boolean, upstreamProxyUrl: string, failMsg?: string, customTag?: unknown }
    // If the function is not defined or is null, the server runs in simple mode.
    // Note that the function takes a single argument with the following properties:
    // * request      - An instance of http.IncomingMessage class with information about the client request
    //                  (which is either HTTP CONNECT for SSL protocol, or other HTTP request)
    // * username     - Username parsed from the Proxy-Authorization header. Might be empty string.
    // * password     - Password parsed from the Proxy-Authorization header. Might be empty string.
    // * hostname     - Hostname of the target server
    // * port         - Port of the target server
    // * isHttp       - If true, this is a HTTP request, otherwise it's a HTTP CONNECT tunnel for SSL
    //                  or other protocols
    // * connectionId - Unique ID of the HTTP connection. It can be used to obtain traffic statistics.
    prepareRequestFunction: ({ request, username, password, hostname, port, isHttp, connectionId }) => {
        return {
            // If set to true, the client is sent HTTP 407 resposne with the Proxy-Authenticate header set,
            // requiring Basic authentication. Here you can verify user credentials.
            requestAuthentication: username !== 'bob' || password !== 'TopSecret',

            // Sets up an upstream HTTP/HTTPS/SOCKS proxy to which all the requests are forwarded.
            // If null, the proxy works in direct mode, i.e. the connection is forwarded directly
            // to the target server. This field is ignored if "requestAuthentication" is true.
            // The username and password must be URI-encoded.
            upstreamProxyUrl: `http://username:[email protected]:3128`,
            // Or use SOCKS4/5 proxy, e.g.
            // upstreamProxyUrl: `socks://username:[email protected]:1080`,

            // Applies to HTTPS upstream proxy. If set to true, requests made to the proxy will
            // ignore certificate errors. Useful when upstream proxy uses self-signed certificate. By default "false".
            ignoreUpstreamProxyCertificate: true

            // If "requestAuthentication" is true, you can use the following property
            // to define a custom error message to return to the client instead of the default "Proxy credentials required"
            failMsg: 'Bad username or password, please try again.',

            // Optional custom tag that will be passed back via
            // `tunnelConnectResponded` or `tunnelConnectFailed` events
            // Can be used to pass information between proxy-chain
            // and any external code or application using it
            customTag: { userId: '123' },
        };
    },
});

// Emitted when HTTP connection is closed
server.on('connectionClosed', ({ connectionId, stats }) => {
  console.log(`Connection ${connectionId} closed`);
  console.dir(stats);
});

// Emitted when HTTP request fails
server.on('requestFailed', ({ request, error }) => {
  console.log(`Request ${request.url} failed`);
  console.error(error);
});

await server.listen();
console.log(`Proxy server is listening on port ${server.port}`);

import { Server } from 'proxy-chain';
import fs from 'node:fs';
import path from 'node:path';

(async () => {
    // TODO: update these lines to use your own key and cert
    const sslKey = fs.readFileSync(path.join(import.meta.dirname, 'ssl.key'));
    const sslCrt = fs.readFileSync(path.join(import.meta.dirname, 'ssl.crt'));

    const server = new Server({
        // Main difference between 'http' and 'https' is additional event listening:
        //
        // http
        // -> listen for 'connection' events to track raw TCP sockets
        //
        // https:
        // -> listen for 'securedConnection' events (instead of 'connection') to track only post-TLS-handshake sockets
        // -> additionally listen for 'tlsError' events to handle TLS handshake errors
        //
        // Default value is 'http'
        serverType: 'https',

        // Provide the TLS certificate and private key
        httpsOptions: {
            key: sslKey,
            cert: sslCrt,
        },

        // Port where the server will listen
        port: 8443,

        // Enable verbose logging to see what's happening
        verbose: true,

        // Optional: Add authentication and upstream proxy configuration
        prepareRequestFunction: ({ username, hostname, port }) => {
            console.log(`Request to ${hostname}:${port} from user: ${username || 'anonymous'}`);

            // Allow the request
            return {};
        },
    });

    // Handle failed HTTP/HTTPS requests
    server.on('requestFailed', ({ request, error }) => {
        console.log(`Request ${request.url} failed`);
        console.error(error);
    });

    // Handle TLS handshake errors
    server.on('tlsError', ({ error, socket }) => {
        console.error(`TLS error from ${socket.remoteAddress}: ${error.message}`);
    });

    // Emitted when HTTP/HTTPS connection is closed
    server.on('connectionClosed', ({ connectionId, stats }) => {
        console.log(`Connection ${connectionId} closed`);
        console.dir(stats);
    });

    // Start the server
    await server.listen();

    // Handle graceful shutdown
    process.on('SIGINT', async () => {
        console.log('\nShutting down server...');
        await server.close(true);
        console.log('Server closed.');
        process.exit(0);
    });

    // Keep the server running
    await new Promise(() => { });
})();

node https_proxy_server.js

curl --proxy-insecure -x https://localhost:8443 -k https://example.com

import http from 'node:http';
import https from 'node:https';
import { Server } from 'proxy-chain';

// Create agents with keepAlive to enable connection pooling
const httpAgent = new http.Agent({
    keepAlive: true,
    maxSockets: 10,
});

const httpsAgent = new https.Agent({
    keepAlive: true,
    maxSockets: 10,
});

const server = new Server({
    port: 8000,
    prepareRequestFunction: ({ request }) => {
        return {
            upstreamProxyUrl: 'http://proxy.example.com:8080',
            // Or for HTTPS upstream proxy: 'https://proxy.example.com:8080'

            // Agents enable connection pooling to upstream proxy
            httpAgent,    // Used for HTTP upstream proxies
            httpsAgent,   // Used for HTTPS upstream proxies
        };
    },
});

await server.listen();
console.log(`Proxy server is listening on port ${server.port}`);

import { Server, RequestError } from 'proxy-chain';

const server = new Server({
    prepareRequestFunction: ({ request, username, password, hostname, port, isHttp, connectionId }) => {
        if (username !== 'bob') {
           throw new RequestError('Only Bob can use this proxy!', 400);
        }
    },
});

const stats = server.getConnectionStats(connectionId);
console.dir(stats);

{
    // Number of bytes sent to client
    srcTxBytes: Number,
    // Number of bytes received from client
    srcRxBytes: Number,
    // Number of bytes sent to target server (proxy or website)
    trgTxBytes: Number,
    // Number of bytes received from target server (proxy or website)
    trgRxBytes: Number,
}

{
  // Optional HTTP status code of the response. By default it is 200.
  statusCode: 200,

  // Optional HTTP headers of the response
  headers: {
    'X-My-Header': 'bla bla',
  }

  // Optional string with the body of the HTTP response
  body: 'My custom response',

  // Optional encoding of the body. If not provided, defaults to 'UTF-8'
  encoding: 'UTF-8',
}

import { Server } from 'proxy-chain';

const server = new Server({
    port: 8000,
    prepareRequestFunction: ({ request, username, password, hostname, port, isHttp }) => {
        return {
            customResponseFunction: () => {
                return {
                    statusCode: 200,
                    body: `My custom response to ${request.url}`,
                };
            },
        };
    },
});

await server.listen();
console.log(`Proxy server is listening on port ${server.port}`);

import http from 'node:http';
import { Server } from 'proxy-chain';

const exampleServer = http.createServer((request, response) => {
    response.end('Hello from a custom server!');
});

const server = new Server({
    port: 8000,
    prepareRequestFunction: ({ request, username, password, hostname, port, isHttp }) => {
        if (request.url.toLowerCase() === 'example.com:80') {
            return {
                customConnectServer: exampleServer,
            };
        }

        return {};
    },
});

await server.listen();
console.log(`Proxy server is listening on port ${server.port}`);

import https from 'node:https';
import fs from 'node:fs';

const key = fs.readFileSync('./test/ssl.key');
const cert = fs.readFileSync('./test/ssl.crt');

const exampleServer = https.createServer({
    key,
    cert,
}, (request, response) => {
    response.end('Hello from a custom server!');
});

await server.close(true);
console.log('Proxy server was closed.');

server.on('tunnelConnectResponded', ({ proxyChainId, response, socket, head, customTag }) => {
    console.log(`CONNECT response headers received: ${response.headers}`);
});

listenConnectAnonymizedProxy(anonymizedProxyUrl, ({ response, socket, head }) => {
    console.log(`CONNECT response headers received: ${response.headers}`);
});

server.on('tunnelConnectFailed', ({ proxyChainId, response, socket, head, customTag }) => {
    console.log(`CONNECT response failed with status code: ${response.statusCode}`);
});

import puppeteer from 'puppeteer';
import { anonymizeProxy, closeAnonymizedProxy } from 'proxy-chain';

(async() => {
    const oldProxyUrl = 'http://bob:[email protected]:8000';
    const newProxyUrl = await anonymizeProxy(oldProxyUrl);

    // Prints something like "http://127.0.0.1:45678"
    console.log(newProxyUrl);

    const browser = await puppeteer.launch({
        args: [`--proxy-server=${newProxyUrl}`],
    });

    // Do your magic here...
    const page = await browser.newPage();
    await page.goto('https://www.example.com');
    await page.screenshot({ path: 'example.png' });
    await browser.close();

    // Clean up
    await closeAnonymizedProxy(newProxyUrl, true);
})();

const host = await createTunnel('http://bob:[email protected]:8000', 'service.example.com:356');
// Prints something like "localhost:56836"
console.log(host);

// Prints 'http://bob:<redacted>@example.com'
console.log(redactUrl('http://bob:[email protected]'));