How to Expose a Local API to the Internet for Development and Testing

Why localhost Is Not Enough

When you start a development server, it listens on 127.0.0.1 or localhost. That address is private to your computer. Nothing outside your machine can reach it. This is fine for solo development, but it becomes a hard blocker the moment anyone or anything else needs to talk to your API.

How It Works

Localtonet creates an encrypted tunnel between your local machine and a relay server. Anyone who connects to the relay address is forwarded to your local API transparently. Your API never knows the difference. You get a public URL without touching your router, opening firewall ports, or having a public IP address.

Option A: HTTP Tunnel (for REST APIs and Web Services)

Use an HTTP tunnel when your API serves HTTP or HTTPS traffic. Localtonet provides a public URL and handles TLS automatically. Your local server can stay on plain HTTP.

localtonet --authtoken <YOUR_TOKEN>

Your API is now reachable at the HTTPS URL shown in the dashboard. Test it immediately from another machine or browser:

# Replace with your actual tunnel URL
curl https://abc123.localto.net/api/users

# POST request
curl -X POST https://abc123.localto.net/api/orders \
  -H "Content-Type: application/json" \
  -d '{"item": "keyboard", "qty": 1}'

Option B: TCP Tunnel (for gRPC, WebSockets, or Non-HTTP APIs)

Use a TCP tunnel when your API uses a non-HTTP protocol such as gRPC, WebSockets over a raw TCP connection, database protocols, or any other TCP-based service. TCP tunnels forward raw traffic without protocol inspection.

Real-World Scenarios

Quick Start by Framework

The steps are the same regardless of what your API is built with. Start the server, create the tunnel, use the URL.

Node.js / Express

// server.js
const express = require('express')
const app = express()
app.use(express.json())

app.get('/api/hello', (req, res) => {
  res.json({ message: 'Hello from local API' })
})

app.listen(3000, () => console.log('API running on http://localhost:3000'))

node server.js
# Now create an HTTP tunnel to port 3000 in the Localtonet dashboard

Python / FastAPI

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/api/hello")
def hello():
    return {"message": "Hello from local API"}

uvicorn main:app --port 8000
# Now create an HTTP tunnel to port 8000 in the Localtonet dashboard

Python / Flask

# app.py
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/hello')
def hello():
    return jsonify(message='Hello from local API')

if __name__ == '__main__':
    app.run(port=5000)

python app.py
# Now create an HTTP tunnel to port 5000 in the Localtonet dashboard

Go

// main.go
package main

import (
    "encoding/json"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"message": "Hello from local API"})
}

func main() {
    http.HandleFunc("/api/hello", helloHandler)
    http.ListenAndServe(":8080", nil)
}

go run main.go
# Now create an HTTP tunnel to port 8080 in the Localtonet dashboard

Security During Development

Frequently Asked Questions