How to Make Your Localhost Server Available Online

Introduction: From Localhost to the World

As a developer, your local machine is your sanctuary. You build, test, and iterate on applications using a localhost server, a private loopback address (like 127.0.0.1) that lets you see your work in action without needing an internet connection. This setup is fast, secure, and perfect for the initial stages of development.

But what happens when you need to break out of this local bubble?

• You need to test a webhook integration from a third-party service like Stripe, Shopify, or Slack, which can only send requests to a public URL.
• You want to show a client or a colleague a work-in-progress without deploying it to a staging server.
• You need to test your web app on a real mobile device, not just a browser emulator.
• You are collaborating with a frontend developer who needs to hit your backend API from their own machine.

In all these scenarios, your private localhost server needs a public, internet-accessible address. You need to bring your localhost online. This guide will show you exactly how to do that using Tunnelmole, a free and open-source tool that makes this process incredibly simple.

What is Localhost?

Before we dive into the solution, let’s quickly clarify what localhost means. In computer networking, localhost is a hostname that refers to the current computer used to access it. When you navigate to http://localhost:3000 in your browser, you’re telling your computer to connect to a service running on itself on port 3000. It’s a closed loop; the network request never leaves your machine.

This is fantastic for development because it’s fast and isolated. However, its greatest strength is also its biggest limitation: it’s inaccessible to anyone or anything on the outside internet.

How to Get a Public URL for Your Localhost server

The easiest way to expose your local server to the internet is by using a tunneling service. These services create a secure „tunnel“ from a public URL to the localhost server running on your machine.

Tunnelmole is a simple, open-source tool designed specifically for this purpose. With a single command, it provides a unique public URL that forwards all incoming traffic directly to your local application.

Key Features of Tunnelmole

• Open Source: The code for both the client and server is fully open source, so you can inspect it and understand exactly how it works. This is a huge plus for security and transparency.
• Free to Use: You can get public URLs for free without even creating an account.
• Optionally Self-Hostable: For ultimate control and privacy, you can host the Tunnelmole service on your own server.
• Simple Command-Line Interface (CLI): It’s designed to be intuitive and get out of your way.
• Cross-Platform: Works on Linux, macOS, and Windows.

Getting Started with Tunnelmole

Let’s get your localhost server online. The process is straightforward and should only take a few minutes.

Step 1: Install Tunnelmole

There are a few ways to install Tunnelmole, depending on your operating system and preferences.

Linux, macOS, and Windows Subsystem for Linux (WSL)

The quickest way is to run the installer script. Open your terminal and execute the following command:

curl -O https://install.tunnelmole.com/xD345/install && sudo bash install

This script automatically detects your OS and installs the correct precompiled binary, which includes the necessary Node.js runtime.

Windows

For Windows users, you can download the tmole.exe executable directly.

1. Download tmole.exe
2. Place the downloaded file in a folder that is part of your system’s PATH environment variable. This makes it so you can run the tmole command from any directory in your command prompt or PowerShell.

Using NPM

If you have Node.js (version 16.10 or later) installed, you can use the Node Package Manager (NPM) to install Tunnelmole globally:

sudo npm install -g tunnelmole

Step 2: Run Your Local Application

Before you can make it public, you need to have a web application running locally. For this example, let’s assume you have a simple Node.js Express server running on port 3000. If your application uses a different port, just take note of it.

You can use this sample Express app if you don’t have one handy. Save it as app.js:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('<h1>Success! My localhost is now online!</h1>');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

Install the dependency (npm install express) and run it (node app.js). Your server is now listening on http://localhost:3000.

Step 3: Go Online with Tunnelmole!

Now for the magic. Open a new terminal window (leave your local server running) and execute the following command:

tmole 3000

Replace 3000 with the port your application is running on. Tunnelmole will start up and display your public URLs.

$ tmole 3000
Your Tunnelmole Public URLs are below and are accessible internet wide. Always use HTTPs for the best security

https://cqcu2t-ip-49-185-26-79.tunnelmole.net ⟶ http://localhost:3000
http://cqcu2t-ip-49-185-26-79.tunnelmole.net ⟶ http://localhost:3000

That’s it! Your localhost server is now online. You can take the https:// URL and share it with anyone or plug it into a third-party service. When someone visits that URL, Tunnelmole forwards the request to your local application running on port 3000.

How Does It Work?

The concept behind Tunnelmole is straightforward but powerful.

1. Client Connection: When you run the tmole command, the client on your machine establishes a persistent WebSocket connection to the Tunnelmole service server.
2. Public URL Assignment: The Tunnelmole service assigns a unique public subdomain (e.g., cqcu2t-ip-49-185-26-79.tunnelmole.net) and points it to the server.
3. Request Forwarding: When an incoming HTTP request hits your public URL, the Tunnelmole service receives it.
4. Tunneling: The service sends the request data through the established WebSocket tunnel back to the Tunnelmole client on your computer.
5. Local Delivery: The client receives the data and forwards the request to your local server (e.g., http://localhost:3000).
6. Response Handling: The response from your local server travels back along the same path, and the Tunnelmole service serves it to the original visitor.

This entire process happens almost instantly, allowing real-time interaction with your local application from anywhere in the world.

Practical Use Cases for Making Localhost Online

Putting your localhost server online isn’t just a neat trick; it’s a massive productivity booster for developers.

1. Developing and Testing Webhooks

Webhooks are essential for modern applications. Services like Stripe, GitHub, Shopify, and Slack use them to send you real-time notifications about events (e.g., a new subscription, a git push, a new order). The catch is that these services must be able to reach your application’s endpoint, which is impossible with localhost.

With Tunnelmole, you can simply provide your public URL to the webhook service. Now, you can debug webhook handlers in real-time, set breakpoints in your code, and inspect the exact payload being sent, dramatically speeding up development.

2. Live Mobile and Cross-Device Testing

Browser developer tools do a great job of emulating mobile viewports, but they can’t replicate the nuances of a real device’s hardware, operating system, or touch interface. To truly test the mobile experience, you need to open your site on an actual phone or tablet. By running Tunnelmole, you can simply access the public URL from any device connected to the internet and interact with your locally-hosted site.

3. Sharing and Collaboration

Imagine you’ve just built a new feature and want to get immediate feedback from your project manager or a frontend developer you’re working with. Instead of a lengthy process involving screenshots, git pushes, and deployments to a shared staging server, you can just send them your Tunnelmole URL. They can see and interact with your work live, as it runs on your machine.

4. Bypassing Corporate Firewalls and Complex Networks

Sometimes you’re developing on a restrictive corporate network that blocks inbound connections. Tunnelmole bypasses this by establishing an outbound connection to its server. As long as you have outbound internet access, you can get a public URL for your local service.

Advanced Usage: Custom Subdomains and Programmatic Use

Tunnelmole also offers features for more advanced workflows.

Custom Subdomains

While the randomly generated URLs are fine for temporary use, sometimes you need a consistent address. Tunnelmole supports custom subdomains. If you use the hosted service, this is a paid feature. However, because Tunnelmole is open source, you can self-host the service and use custom subdomains for free.

To use a custom subdomain, the command is:

tmole <port> as my-cool-app.tunnelmole.net

Integrating with NodeJS Projects

You can also use Tunnelmole as an NPM package directly within your Node.js projects. This is useful for automating your development environment.

First, install it as a development dependency:

npm install --save-dev tunnelmole

Then, you can use it in your code:

import { tunnelmole } from 'tunnelmole';

// This will start a tunnel for port 3000 and return the public URL
const url = await tunnelmole({
    port: 3000
});

console.log(`My app is public at: ${url}`);

You can even integrate it into your package.json scripts to start your app and the tunnel with a single command:

{
  "scripts": {
    "start": "node app.js",
    "share": "npm run start & tmole 3000"
  }
}

Now, running npm run share will start your server and immediately make it available online.

Conclusion: Your Localhost, Reimagined

The barrier between localhost and the internet is no longer a rigid wall. With tools like Tunnelmole, it’s a permeable membrane that you can open on demand. By making your localhost server available online, you can streamline workflows, simplify testing, and collaborate more effectively.

Because Tunnelmole is open source and can be self-hosted, it offers a level of transparency, security, and control that proprietary services can’t match. Whether you’re debugging a tricky webhook, testing on a mobile device, or just want to share your work, give Tunnelmole a try and see how it can supercharge your development process.