Node Unblocker 2025: Build a Web Scraping Proxy

Node Unblocker is a small Node.js library that turns your machine into a rewriting web proxy. It stands up a server that intercepts requests, forwards them to a target site, and relays the response back, rewriting URLs along the way. That makes it a handy building block for collecting public data, running QA against your own web properties, or reaching region-specific versions of a site you have a legitimate reason to test.

This guide walks through building a Node Unblocker instance from scratch with Express, testing it locally, and deploying it to a cloud VM so requests originate from a server IP rather than your home connection. We'll keep everything grounded in legitimate use: public data, research, and testing in line with each target site's terms of service.

What Node Unblocker actually does

Node Unblocker is built on the Express framework and lets you spin up a personal web proxy in a handful of lines. Like any proxy, it sits between your client and the destination server: it takes an outgoing request, sends it to the target, and passes the response back to you.

On top of plain proxying, it rewrites URLs, typically prefixing the real address with a path like /proxy/. So instead of visiting https://example.com directly, you visit http://yourserver/proxy/https://example.com, and the tool handles the round trip.

It's not a universal solution, and it's honest to say where it falls short. Node Unblocker can struggle with heavily client-rendered, modern pages. Sites that lean on postMessage for cross-frame communication (common on social platforms), complex AJAX flows, or OAuth login sequences may not render or behave correctly, because the tool doesn't proxy every one of those interactions cleanly. For those cases you're better off with a real headless browser, which we'll come back to later.

How the middleware makes it flexible

Node Unblocker's core job is managing HTTP/S traffic between your client and the destination site. Its real value, though, comes from its middleware system, which lets you inspect and modify requests and responses in ways typical proxy providers don't expose. A few features worth knowing about:

• Content Security Policy (CSP) removal: Stripping CSP headers can prevent proxied pages from breaking when they try to load resources from other origins, and it lets inline scripts run, which helps with content that hydrates via JavaScript.

• Cookie management: Correct cookie handling keeps sessions alive across multi-step flows, such as logging into an account you own or completing a checkout in a test environment.

• Redirect handling: Middleware ensures HTTP redirects are followed through the proxy rather than leaking requests around it.

You also get fine-grained control over request headers and general proxy behaviour. For example, Node Unblocker forces client-side JavaScript through the proxy by default, and you can turn that off when a particular workflow doesn't need it.

Prerequisites

Starting from scratch, you'll want a few things in place:

• Node.js runtime: Node Unblocker is a Node.js library, so you need the runtime installed. Grab it from the official Node.js site.

• An editor or IDE: A plain text editor works, but a web-focused editor like Visual Studio Code or WebStorm makes life easier. The steps below apply to any of them.

• (Optional) A cloud server: Running locally means requests still come from your own IP. To reach geo-specific content or run larger public-data collection, deploying to a cloud VM is the practical move, once your local setup works.

Installing Node.js and the packages

Open your editor's terminal (or your system command line), move into your project directory, and initialize a Node.js project:

npm init -y

The -y flag accepts the default configuration. You can drop it to customise metadata like the package name or version, but none of that is critical for a simple setup.

Next, install Node Unblocker and Express:

npm

This adds unblocker and express to your dependencies, creates a node_modules directory, and updates package.json, which tracks your dependencies and settings.

Now create a file named server.js in your project root and import the libraries:

// Import necessary modules
const express = require('express');
const Unblocker = require('unblocker');

We use const because we won't reassign these variables. require is Node.js's module import mechanism: when you call require('module_name'), Node looks up and loads the module from its core libraries or from node_modules.

Creating the proxy instance

Set up the Express app and register the Node Unblocker middleware:

// Initialize Express app
const app = express();

// Configure Node Unblocker instance
const unblocker = new Unblocker({ prefix: '/myproxy/' }); // Using a different prefix

// Apply the unblocker middleware
app.use(unblocker);

First we create an Express application (app). Then we initialize Node Unblocker with a config object. The prefix option (here /myproxy/) sets the URL path that triggers proxying. A request to http://yourserver/myproxy/https://example.com routes through Node Unblocker, while requests without the prefix skip the middleware entirely.

Finally, app.use(unblocker) registers the instance so matching requests are handled by it. You can also define a port:

// Define a port (optional, defaults often work)
const customPort = 8081;

Launching the server

Now tell Express to start listening:

// Define the port the server will listen on
const PORT = process.env.PORT || customPort || 8080; // Use environment variable, custom port, or default

// Start the server and handle upgrades
app.listen(PORT)
   .on('upgrade', unblocker.onUpgrade);

// Log a confirmation message
console.log(`Node Unblocker proxy running on port: ${PORT}`);

app.listen(PORT) starts the server. It first tries a port from the environment (process.env.PORT), falls back to customPort, then defaults to 8080, which is handy for cloud platforms that assign a port at runtime.

The .on('upgrade', unblocker.onUpgrade) line matters: it lets Node Unblocker handle protocol upgrades like WebSockets, keeping it compatible with sites that use those protocols. The console.log simply confirms the server is up and on which port.

Testing locally

Always run a local test before deploying, to catch obvious errors. Move into your project directory if you aren't already there:

cd

Then start the server:

node

Once you see the confirmation message, open a browser and go to:

Replace PORT with the port shown in your console (8081 or 8080), /myproxy/ with your configured prefix, and https://example.com/ with whatever site you want to test. If everything's wired up, the page loads in your browser served through your local proxy. You can also test from the command line with cURL if you prefer a scriptable check.

Deploying to a remote server

A local instance is fine for testing, but every request still carries your own IP. Deploying to a cloud VM gives Node Unblocker a server IP instead, which is what you want for reaching region-specific public data or running steadier collection jobs. Plenty of providers offer suitable VMs, Google Cloud Compute Engine, AWS EC2, DigitalOcean, Render, and others. We'll use Google Cloud as an example thanks to its low-cost small instances.

First, make sure package.json is deployment-ready with a Node version and a start script:

{
  "name": "my-node-unblocker",
  "version": "1.0.0",
  "description": "A simple Node Unblocker proxy",
  "main": "server.js",
  "private": true,
  "scripts": {
    "start": "node server.js"
  },
  "engines": {
    "node": ">=18.0.0"
  },
  "dependencies": {
    "express": "^4.18.2",
    "unblocker": "^2.3.0"
  }
}

The scripts.start command tells the host how to run the app, and engines.node pins the compatible Node range.

Next, create a VM instance with your provider. Pick an OS (Ubuntu or Debian are safe), a machine type (a small one like e2-micro or e2-small is usually enough), and a region. Launch it, then connect over SSH, either the browser-based console most providers offer or a standard SSH client from your terminal. You'll land in a Linux shell.

On Ubuntu/Debian you may need to bind to all interfaces so external clients can connect:

// Listen on all interfaces for external access
app.listen(PORT, '0.0.0.0')
   .on('upgrade', unblocker.onUpgrade);

console.log(`Node Unblocker proxy running on port: ${PORT}, accessible externally`);

Upload your project files (server.js, package.json). Browser SSH usually has an upload button, or use scp:

Install Node.js and npm on the VM (follow the current instructions for your Linux distribution from the official Node docs), then install dependencies and start the server:

cd /path/on/server/
npm install
npm start

When you see the confirmation message, test from your local browser through the deployed proxy:

Swap in your VM's public IP, the correct port, and your prefix. Hitting httpbin.org/ip returns the requesting IP, which should be your VM's, not your local one. If the connection fails, check your provider's firewall rules and open incoming TCP traffic on the port you're using (e.g. 8080 or 8081). For a cleaner deployment that survives reboots, it's worth running the app as a managed service; our guide on turning scripts into Windows, Linux and cloud services covers the same idea for long-running processes.

Where a single VM runs out of road

You now have a working Node Unblocker proxy, local or remote, useful for light public-data collection and testing, as long as it stays within your cloud provider's terms of service and the target site's rules.

The catch is scale. One instance on one VM means every request leaves from a single IP. Many public sites rate-limit per IP, so a single address quickly hits those limits during any meaningful collection run. You can distribute load by running several instances across different VMs, effectively hand-rolling a small proxy pool, but that gets expensive and fiddly to maintain fast.

Once managing VMs becomes the bottleneck, a dedicated proxy service is usually the more practical path. A pool of ethically sourced residential proxies, or datacenter IPs for cheaper high-volume work, gives you geographic coverage and per-request IP rotation without provisioning servers yourself. Evomi's datacenter proxies start at $0.30/GB and residential at $0.49/GB, and there are free trials on residential, mobile and datacenter plans so you can compare against your VM setup before committing. If you'd rather not run any of the routing yourself, see our datacenter proxy setup guide to get up and running quickly.

And if your targets rely on the heavy client-side rendering that trips up Node Unblocker, a managed Scraping Browser (cloud headless Chromium, Playwright/Puppeteer compatible) handles the JavaScript execution and connection routing for you, which is a better fit than trying to force a rewriting proxy to render a modern single-page app.

===CONTENT===