This tutorial will be showing you how to expose localhost to Internet with PageKit on Ubuntu.

Normally if you want to visit your home web server from outside, you need to set up dynamic DNS because your ISP doesn’t give you a static public IP address. But some ISPs in the world don’t even assign a dynamic public IP address to each subscriber. Many subscribers share a single public IP address. In this scenario, dynamic DNS won’t work and that’s where PageKite comes in.

PageKite is an open-source tunneled reverse proxy that is capable of bypassing NATs (network address translation), firewalls and making local web servers and SSH servers visible to the public Internet. If you are a web developer or have some self-hosted services like NextCloud on your home network, then PageKite can help you access them remotely over the Internet. PageKite is written in Python, so it can run on many kind of devices.

Note: Making your web server/SSH server visible to the Internet also expose them to hackers.

How Pagekite works

  1. Your services, typically one or more HTTP servers, run on localhost.
  2. You run pagekite as a back-end connector, on the same machine.
  3. Another instance of pagekite runs as a front-end relay on a machine with a public IP address, in “the cloud”.
  4. The back-end pagekite connects to the front-end, and creates a tunnel for the configured services.
  5. Clients, typically web browsers, connect to the front-end and request service. The front-end relays the request over the appropriate tunnel, where the back-end forwards it to the actual server. Responses travel back the same way.

Running your own front-end relay costs a little money, but PageKite developers offer a 31 days free account for you to try it out. Let’s see how to use PageKite with a free account. This tutorial will only show how to expose local web server. Exposing local SSH server will be discussed in another tutorial.

Expose Localhost to Internet with PageKite on Ubuntu

First, install a web server, such as Apache, on your local Linux computer. On Debian/Ubuntu based Linux distro, run the following command to install Apache web server.

sudo apt install apache2

Start the web server

sudo systemctl start apache2

Now Apache is listening on port 80. We use PageKite to make it visible to the Internet. Install PageKit on your Linux computer using the following command.

Debian 8/9, Ubuntu 16.04/18.04,  Raspbian and derivatives

sudo apt install pagekite

Next, run the following command. Replace name with your desired subdomain.


It will first ask you if you want to use the free service. Since you don’t have your own PageKite server yet, choose Y.

Then PageKit will prompt you to sign up for a account using your email address.

You account details including password will be sent to your email address. Open the email and click the link in it to activate your account. Then enter Y to continue and save your settings.

Now PageKite will connect to the front end.

And you should be able to access your local web server using a domain name.


To stop PageKite, press Ctrl C in the terminal window. If you want to run PageKite in the background, use --daemonize option.

pagekite --daemonize

To stop daemonized PageKite, run

pkill pagekite

You can password protect your web page with HTTP basic authentication like below.

pagekite  password/username=pass allows paid members to use their own domain names by setting up CNAME record. Instructions can be found on its website.

How to Run Your Own PageKite Server

The free trial of is very limited. However, we can run our own PageKite server (aka the front end) on a public-facing Linux VPS (Virtual Private Server). Although this costs money, but running your own PageKite server is well worth it. If you choose to pay service, then for 5 USD a month, you get only 4GB of transfer quota.

If you buy a Linux VPS from TurnkeyInternet and run your own PageKite server on it, then for 4.99 USD per month, you get a Gigabit network port and unmetered bandwidth. Besides, you can do other interesting projects on your VPS like setting up your own VPN.

You will also need a domain name. You may have heard of GoDaddy, but you want to buy domain names from Namecheap because their price is lower than GoDaddy and they give you whois privacy protection free of charge.

Now, suppose you have bought a VPS and a domain name, here’s how to run the front end pagekite server. Install Ubuntu 18.04 OS on your VPS in Linode control panel. Then SSH into your VPS and install Pagekite with the commands below.

sudo apt update

sudo apt install pagekite

The website also has instructions on installing RPM packages on CentOS. Once pagekite is installed, the configuration directory is located at /etc/pagekite.d/ . We need to edit 20_frontends.rc file.

sudo nano /etc/pagekite.d/20_frontends.rc

Comment out the line that reads defaults because we don’t want to use the service. Next, add the following lines at the end of the file. Replace with your own domain name and your-secret-key with your preferred secret key. I use my domain name as an example.


Save and close the file. Then start Pagekite server with the command below, specifying the option file. Because PageKite server needs TCP port 80 and 443 to work, so we need to prefix the command with sudo.  Also make sure no other process on your VPS are using these two ports.

sudo pagekite --optfile=/etc/pagekite.d/20_frontends.rc

To run Pagekite server in the background, use --daemonize option.

sudo pagekite --optfile=/etc/pagekite.d/20_frontends.rc --daemonize

In your DNS manager, create a sub-domain for pagekite with A record pointing to the IP address of your VPS like below.


Create a Systemd Service Unit for PageKite Server

The default systemd service file /lib/systemd/system/pagekite.service is intended for use as a client. We can create a separate systemd service file for PageKite server.

sudo nano /etc/systemd/system/pagekite.service

Copy and paste the following lines into the file.


ExecStart=/usr/bin/pagekite --clean --optdir=/etc/pagekite.d/


# Hardening
[email protected] @debug @cpu-emulation @debug @keyring @module @mount @obsolete @raw-io @reboot @swap


Save and close the file. Then reload systemd for the change to take effect.

sudo systemctl daemon-reload

Next, open 10_account.rc file

sudo nano /etc/pagekite.d/10_account.rc

This is a configuration file used by PageKite client. The PageKite systemd service will read every .rc file in /etc/pagekite.d/ directory in lexicographical order, so we need to comment out everything in this file. After that, you can kill the daemonized pagekite server process.

sudo pkill pagekite

Restart it with systemctl.

sudo systemctl start pagekite

To enable auto start at system boot time, run

sudo systemctl enable pagekite

To disable auto start, run

sudo systemctl disable pagekite

Check its status.

systemctl status pagekite

Configure Pagekite Client to Use Your Own Server

On your local computer where the Pagekite client is installed, edit the 10_account.rc file.

sudo nano /etc/pagekite.d/10_account.rc

Replace the value of kitename and kitesecret with the domain name and secret key you specified on your Pagekite server, respectively. And comment out the last line.

Save and close the file. Then edit 20_frontends.rc file.

sudo nano /etc/pagekite.d/20_frontends.rc

Comment out the line that reads defaults. Then add the following line.

frontend = your-pagekite-server-IP:80

Save and close the file. Next, rename 80_httpd.rc.sample to 80_httpd.rc

sudo mv /etc/pagekite.d/80_httpd.rc.sample /etc/pagekite.d/80_httpd.rc

Restart Pagekite service on the local computer.

sudo systemctl restart pagekite

Your local Pagekite client should now be connected to your own Pagekite server. You can check the connection details by running:

sudo systemctl status pagekite

And your local web server is now exposed to the Internet. If the connection to the Pagekite server is lost, the Pagekite service will attempt to re-establish a connection.

Note: If you run command pagekite on your local computer, it will use the ~/.pagekite.rc user configuration file, which defaults to using service.

Multiple Virtual Hosts

This section explains how to make multiple Apache virtual hosts on your home network visible to the Internet. First, let me create two example Apache virtual hosts.

First virtual host

sudo nano /etc/apache2/sites-available/

Content in this file:

       DocumentRoot /var/www/

Create the document root directory.

sudo mkdir /var/www/

Then create an index.html file.

echo "This is site #1." | sudo tee /var/www/

Second virtual host

sudo nano /etc/apache2/sites-available/

Content in this file:

       DocumentRoot /var/www/

Create the document root directory.

sudo mkdir /var/www/

Then create an index.html file.

echo "This is site #2." | sudo tee /var/www/

Enable these two virtual hosts.

sudo a2ensite

sudo a2ensite

Reload Apache web server for the changes to take effect.

sudo systemctl reload apache2

PageKite Server Configuration

Edit the 20_frontends.rc file on the PageKite server.

sudo nano /etc/pagekite.d/20_frontends.rc

Add two domain definitions like below.


Save and close the file. Then restart PageKite.

sudo systemctl restart pagekite

PageKite Client Configuration

Edit the 80_httpd.rc file on local computer.

sudo nano /etc/pagekite.d/80_httpd.rc

Add two back-end defintions like below.

service_on = : localhost:80 : secret-key
service_on = : localhost:80 : secret-key

Save and close the file. Then restart PageKite.

sudo systemctl restart pagekite

Finally, add DNS A record for each subdomain. Now if I visit, I get

If I visit, I get

As you can see, Pagekite correctly responded to each HTTP request. If it’s not working for you, check if your secret keys match or if there’s typo in your configuration file.

How to Enable HTTPS

We can terminate TLS either at the back-end or at the front-end. The former is easier and more convenient. So I will show you how to install TLS certificate on the local computer. We can obtain free Let’s Encrypt TLS certificate for each subdomain. First, install Let’s Encrypt client (certbot) and the Apache plugin on the local computer.

sudo apt install certbot python3-certbot-apache

Then obtain and install TLS certificate for each subdomain with the commands below.

sudo certbot --apache --agree-tos --redirect --hsts --staple-ocsp --must-staple --email your-email-address -d

sudo certbot --apache --agree-tos --redirect --hsts --staple-ocsp --must-staple --email your-email-address -d


  • --agree-tos: Agree to terms of service.
  • --redirect: Redirect HTTP to HTTPS
  • --hsts: Enable strict transport security header.
  • --staple-ocsp: Enable OCSP stapling
  • --must-staple: Adds the OCSP Must Staple extension to the certificate.

After certificates are successfully obtained and installed, edit the 80_httpd.rc file on the local computer.

sudo nano /etc/pagekite.d/80_httpd.rc

Add two HTTPS back-end definition like below. Notice that HTTPS requests will be sent to port 443 on localhost.

service_on = : localhost:443: your-secret-key
service_on = : localhost:443: your-secret-key

Save and close the file. Then restart pagekite client.

sudo systemctl restart pagekite

Now my sites are automatically redirected to HTTPS.

Auto Renew TLS Certificate

The certbot debian package ships with its own cron job (/etc/cron.d/certbot) and a systemd timer (/lib/systemd/system/certbot.timer) to automatically renew TLS certificate. So you don’t need to manually add cron job or systemd timer. The timer runs certbot.service twice a day. You can check its status with:

systemctl status certbot.timer

If the certbot cron job detects that there’s also a systemd timer, then it won’t run the renew command.

Wrapping Up

That’s it! I hope this PageKite tutorial helped you expose localhost to Internet with PageKite on Ubuntu. As always, if you found this post useful,  subscribe to our free newsletter to get more tips and tricks 🙂

Rate this tutorial

[Total: 6 Average: 4.5]