Tunneling and Remote Access Platform

https://pinggy.io/docs
Admin
This project provides comprehensive documentation for a platform that enables secure tunneling,...
Tokens:33,540
Snippets:534
Trust Score:9.9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Start Tunnel with Key Authentication (Customized Command)

Source: https://pinggy.io/docs/http_tunnels/key_auth

A customized SSH command to start a tunnel with key authentication. This example uses 'samplekey' and includes common options like StrictHostKeyChecking and ServerAliveInterval.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -t -R0:localhost:8000 free.pinggy.io "k:samplekey"
```

--------------------------------

### Example: Advanced Tunnel Configuration

Source: https://pinggy.io/docs/cli

This example starts a tunnel forwarding connections to local port 3000 and also launches the web debugger on port 4300.

```bash
./pinggy -p 443 -R0:localhost:3000 -L4300:localhost:4300
```

--------------------------------

### Enable and Start OpenSSH Server via PowerShell

Source: https://pinggy.io/docs/guides/ssh_windows

Use this PowerShell command to install the OpenSSH Server capability, start the sshd service, and configure it to start automatically on Windows.

```powershell
Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
Start-Service sshd
Set-Service -Name sshd -StartupType 'Automatic'
```

--------------------------------

### Install Netdata Agent

Source: https://pinggy.io/docs/guides/netdata

Use this command to install the Netdata agent on most Linux distributions. This script handles the setup and configuration.

```bash
bash <(curl -SsL https://get.netdata.cloud/kickstart.sh)
```

--------------------------------

### Example: Simple HTTPS Tunnel

Source: https://pinggy.io/docs/cli

Start a tunnel that forwards connections to a local HTTPS server running on localhost:443.

```bash
./pinggy -l https://localhost:443
```

--------------------------------

### Start a Basic Pinggy Tunnel

Source: https://pinggy.io/docs/cli

The basic syntax to start a tunnel using Pinggy CLI. Navigate to the installation directory before running.

```bash
./pinggy <options>
```

--------------------------------

### Start Next.js Development Server

Source: https://pinggy.io/docs/guides/nextjs

Run this command to start your Next.js project. The application will be accessible at http://localhost:3000 by default.

```bash
npx next start
```

--------------------------------

### Install Pinggy Skill for any Agent

Source: https://pinggy.io/docs/ai_agents

Use this command to install the Pinggy skill, which provides packaged instructions and reference documentation for an AI agent. Ensure Node.js is installed.

```bash
npx skills add https://pinggy.io
```

--------------------------------

### Start TLSTCP Tunnel with Specific CIDR Whitelist

Source: https://pinggy.io/docs/tlstcp_tunnels/ip_whitelist

This command demonstrates starting a TLSTCP tunnel with a specific IP address and CIDR notation for whitelisting. This example restricts access to the /24 subnet of 54.88.149.108. Ensure to use appropriate options for host key checking and keep-alive.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -t -R0:localhost:8000 tlstcp@free.pinggy.io "w:54.88.149.108/24"
```

--------------------------------

### Start Nginx Web Server

Source: https://pinggy.io/docs/guides/apache_nginx

Starts the Nginx web server service. Confirm that Nginx is running and accessible on port 80.

```bash
sudo systemctl start nginx
```

--------------------------------

### Install Pinggy MCP Server Prerequisites

Source: https://pinggy.io/docs/ai_agents

Install uv, a package and virtual environment manager, which is a prerequisite for installing the Pinggy MCP server. Python 3.10 or newer is required.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Install and Enable SSH Server on Fedora

Source: https://pinggy.io/docs/guides/ssh_linux

Installs and enables the OpenSSH server on Fedora systems. This command ensures the SSH daemon is active and starts on boot.

```bash
sudo dnf install openssh-server
sudo systemctl enable --now sshd
```

--------------------------------

### Start a Local HTTP Server with Python

Source: https://pinggy.io/docs

Use this command to quickly launch a basic HTTP server for testing purposes on your localhost.

```bash
python3 -m http.server
```

--------------------------------

### Example Public URLs

Source: https://pinggy.io/docs

These are example HTTP and HTTPS URLs that Pinggy provides to access your local service publicly.

```text
// You can access local server via following URL(s):
http://uljtt-30-47-152-61.run.pinggy-free.link
https://uljtt-30-47-152-61.run.pinggy-free.link
```

--------------------------------

### Start Apache Web Server

Source: https://pinggy.io/docs/guides/apache_nginx

Starts the Apache web server service on Debian/Ubuntu systems. Ensure the server is listening on port 80.

```bash
sudo systemctl start apache2
```

--------------------------------

### Install and Enable SSH Server on Arch Linux

Source: https://pinggy.io/docs/guides/ssh_linux

Installs and enables the OpenSSH server on Arch Linux. This command ensures the SSH daemon is active and starts on boot.

```bash
sudo pacman -S openssh
sudo systemctl enable --now sshd
```

--------------------------------

### Start Auto-Start Tunnels with Remote Management

Source: https://pinggy.io/docs/cli

Start all auto-start tunnels and enable remote management simultaneously.

```bash
pinggy start --all --remote-management <API KEY>
```

--------------------------------

### Start PocketBase Server

Source: https://pinggy.io/docs/guides/pocketbase

Launches the PocketBase server. The default address is http://127.0.0.1:8090.

```bash
./pocketbase serve

```

--------------------------------

### Install Pinggy Node.js SDK

Source: https://pinggy.io/docs

Install the Pinggy Node.js SDK using npm to integrate Pinggy into your Node.js applications.

```bash
npm i @pinggy/pinggy
```

--------------------------------

### Start UDP Tunnel

Source: https://pinggy.io/docs/cli

Start a UDP tunnel and specify the local port to forward to.

```bash
./pinggy --type udp -l 8000
```

--------------------------------

### Install Pinggy CLI using npm

Source: https://pinggy.io/docs/cli

Install the Pinggy CLI globally on your system using npm. This makes the `pinggy` command available system-wide.

```bash
npm install -g pinggy
```

--------------------------------

### Serve Files Locally with Python

Source: https://pinggy.io/docs/guides/sharefiles

Use this command to start a local HTTP server in Python. Navigate to the directory you wish to share before running.

```bash
python -m http.server
```

--------------------------------

### Install and Enable SSH Server on Ubuntu/Debian

Source: https://pinggy.io/docs/guides/ssh_linux

Installs and enables the OpenSSH server on Ubuntu or Debian-based systems. Ensure SSH is running before proceeding.

```bash
sudo apt update
sudo apt install openssh-server
sudo systemctl enable --now ssh
```

--------------------------------

### Verify Pinggy CLI Installation

Source: https://pinggy.io/docs/cli

After installation, verify that the `pinggy` command is accessible and working by running the help command.

```bash
pinggy --help
```

--------------------------------

### Start Multiple or All Auto-Start Tunnels

Source: https://pinggy.io/docs/cli/index.md

Start specific saved tunnels by name, or start all tunnels that are configured for auto-start.

```bash
pinggy start tunnel1 tunnel2
```

```bash
pinggy start --all
```

--------------------------------

### Start Saved Tunnel with Overrides

Source: https://pinggy.io/docs/cli

Starts a saved tunnel configuration and applies runtime overrides for specific options.

```bash
pinggy start my-tunnel -l 4000
```

--------------------------------

### Start Apache httpd Service

Source: https://pinggy.io/docs/guides/apache_nginx

Starts the httpd service, commonly used for Apache on RHEL/CentOS/Fedora systems. Verify it responds on port 80.

```bash
sudo systemctl start httpd
```

--------------------------------

### Start PocketBase Binding to All Interfaces

Source: https://pinggy.io/docs/guides/pocketbase

Starts the PocketBase server and binds it to all network interfaces (0.0.0.0) on port 8090. This is useful when PocketBase and Pinggy run on different machines on the same LAN.

```bash
./pocketbase serve --http=0.0.0.0:8090

```

--------------------------------

### Start Saved Tunnel

Source: https://pinggy.io/docs/cli

Starts a previously saved tunnel configuration.

```bash
pinggy start my-tunnel
```

--------------------------------

### Start Tunnel with Persistent Subdomain

Source: https://pinggy.io/docs/persistent_subdomain

Use this SSH command to start a tunnel with your persistent subdomain. Ensure you have upgraded to Pinggy Pro and obtained your access token from the dashboard.

```bash
ssh -p 443 -R0:localhost:8000 xGBTh6cy58q@pro.pinggy.io
```

--------------------------------

### Start TLS Tunnel with CIDR IP Whitelist

Source: https://pinggy.io/docs/tls_tunnels/ip_whitelist

Initiate a TLS tunnel with IP whitelisting using a CIDR notation for IP ranges. This example whitelists a specific subnet.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -t -R0:localhost:8000 tls@free.pinggy.io "w:54.88.149.108/24"
```

--------------------------------

### Start TCP Tunnel

Source: https://pinggy.io/docs/cli

Start a TCP tunnel and specify the local port to forward to.

```bash
./pinggy --type tcp -l 8000
```

--------------------------------

### Run a Local WebDAV Server with Docker

Source: https://pinggy.io/docs/guides/keepass

Starts a WebDAV server using Docker, mapping a local directory for database storage and configuring basic digest authentication. Ensure your .kdbx file is placed in the mapped host directory.

```bash
docker run --restart always -v /path/to/kdbx:/var/lib/dav \
  -e AUTH_TYPE=Digest -e USERNAME=alice -e PASSWORD=strongpassword \
  -p 8080:80 bytemark/webdav
```

--------------------------------

### Start Multiple Tunnels

Source: https://pinggy.io/docs/cli

Start multiple specified tunnels simultaneously.

```bash
pinggy start tunnel1 tunnel2
```

--------------------------------

### Start TLS Tunnel

Source: https://pinggy.io/docs/cli

Start a TLS tunnel and specify the local port to forward to.

```bash
./pinggy --type tls -l 8000
```

--------------------------------

### SSH Command with Listen Address Examples

Source: https://pinggy.io/docs/http_tunnels/multi_port_forwarding

Demonstrates forwarding specific hostnames and TCP traffic to local services using the SSH -R option with different listen address formats.

```bash
ssh -p 443 \
  -R one.example.com:1:one.local:8888 \
  -R tcp//two.example.com/14578:1:two.local:9999 \
  free.pinggy.io
```

--------------------------------

### Start All Auto-Start Tunnels

Source: https://pinggy.io/docs/cli

Start all tunnels that have been previously marked for auto-start.

```bash
pinggy start --all
```

--------------------------------

### Install Pinggy Python SDK

Source: https://pinggy.io/docs

Install the Pinggy Python SDK using pip to integrate Pinggy into your Python applications.

```bash
pip install pinggy
```

--------------------------------

### Start HTTP Tunnel with QR Code (With Token)

Source: https://pinggy.io/docs/usages

Starts an HTTP tunnel with a token and displays a QR code. This version uses a larger ASCII-only QR code.

```bash
ssh -R0:localhost:<localport> <token>+qr@pro.pinggy.io
```

--------------------------------

### Start HTTP Tunnel With Token

Source: https://pinggy.io/docs/usages

Establishes an HTTP tunnel using a provided token for authentication and identification. Replace `<token>` with your actual Pinggy token. This allows for more controlled access and management of your tunnel.

```bash
ssh -R0:localhost:<localport> <token>@pro.pinggy.io
```

--------------------------------

### Start a Saved Tunnel

Source: https://pinggy.io/docs/cli

Start a previously saved tunnel configuration. You can also override the port.

```bash
pinggy start my-tunnel
```

```bash
pinggy start my-tunnel -l 4000
```

--------------------------------

### Start TLS Tunnel (With Token)

Source: https://pinggy.io/docs/usages

Starts a TLS tunnel using a provided token. This method forwards traffic as is to the client, offering maximum privacy.

```bash
ssh -R0:localhost:<localport> <token>+tls@pro.pinggy.io
```

--------------------------------

### Start Tunnel with Multiple Key Authentication (SSH CLI)

Source: https://pinggy.io/docs/http_tunnels/key_auth

This command allows starting an SSH tunnel with multiple keys, providing flexibility in authentication. Separate keys with spaces.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io k:key1 k:key2
```

--------------------------------

### Start Tunnel with Single Key Authentication (SSH CLI)

Source: https://pinggy.io/docs/http_tunnels/key_auth

Use this command to start an SSH tunnel with a single key for authentication. Ensure the key is correctly formatted.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io k:key
```

--------------------------------

### Example Pinggy SSH Command

Source: https://pinggy.io/docs/run_tunnel_on_startup

This is an example of a Pinggy SSH command that can be used in a batch file. Customize the ports and hostname as needed.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -R0:localhost:8000 free.pinggy.io
```

--------------------------------

### Connect using nc command

Source: https://pinggy.io/docs/client_behind_proxy

Use the `nc` command with `ProxyCommand` to establish a basic SSH connection. This is a fundamental example for bypassing simple restrictions.

```bash
ssh -p443 -R0:localhost:4000 -o ProxyCommand="nc %h %p" free.pinggy.io
```

--------------------------------

### Start HTTP Tunnel on macOS/Windows

Source: https://pinggy.io/docs/docker

Use this command to start an HTTP tunnel on port 8080 on localhost when running Docker on macOS or Windows. Does not require `--net=host`.

```bash
docker run -it pinggy/pinggy -p 443 -R0:localhost:8080 free.pinggy.io
```

--------------------------------

### Start Tunnel with Logging Enabled

Source: https://pinggy.io/docs/cli

Enable verbose logging for a single tunnel using '-vvv' or configure detailed logging for all auto-start tunnels with '--logfile' and '--loglevel'. Note: Advanced logging options are typically for single tunnel starts.

```bash
pinggy start my-tunnel --vvv
```

```bash
pinggy start --all --logfile /tmp/pinggy.log --loglevel DEBUG
```

--------------------------------

### Start HTTP Tunnel on Linux

Source: https://pinggy.io/docs/docker

Use this command to start an HTTP tunnel on port 8080 on localhost when running Docker on Linux. Requires the `--net=host` option.

```bash
docker run --net=host -it pinggy/pinggy -p 443 -R0:localhost:8080 free.pinggy.io
```

--------------------------------

### Start TLS Tunnel with Multiple IP Whitelist

Source: https://pinggy.io/docs/tls_tunnels/ip_whitelist

This command allows you to start a TLS tunnel accessible from multiple specified IP addresses. Separate IPs with commas.

```bash
ssh -p 443 -R0:localhost:8000 -t tls@free.pinggy.io w:[IP1[,IP2[,IP3..]]]
```

--------------------------------

### Pinggy Tunnel Command in Startup Script

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

Paste your Pinggy tunnel command into the startup script. This example runs the tunnel in the background and logs output.

```bash
#!/bin/bash
# Run Pinggy tunnel in the background
ssh -p 443 -R0:localhost:8000 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 free.pinggy.io >> /var/log/pinggy.log 2>&1 &

```

--------------------------------

### Start Pinggy Tunnel with Token

Source: https://pinggy.io/docs/guides/ssh_mac

Use this command with your Pinggy account token to establish a tunnel that provides a persistent address for SSH access.

```bash
ssh -p 443 -R0:localhost:22 <token>+tcp@pro.pinggy.io
```

--------------------------------

### Start HTTP Tunnel with Web Debugger (CLI)

Source: https://pinggy.io/docs/http_tunnels/web_debugger

Use the Pinggy CLI to start an HTTP tunnel and enable the Web Debugger on port 4300. This is an alternative to using the SSH command.

```bash
./pinggy -p 443 -R0:localhost:8080 -L4300:localhost:4300 free.pinggy.io
```

--------------------------------

### Start TCP Tunnel with Single IP Whitelist

Source: https://pinggy.io/docs/tcp_tunnels/ip_whitelist

Use this command to start a TCP tunnel that only accepts connections from a specific IP address. Replace IP1 with the desired IP.

```bash
ssh -p 443 -R0:localhost:8000 -t tcp@free.pinggy.io w:IP1
```

--------------------------------

### Start UDP Tunnel with Pinggy CLI

Source: https://pinggy.io/docs/udp_tunnels

Use this command to initiate a UDP tunnel to localhost. The command provides a URL and a UDP port, which may change with each connection. Pro users can reserve persistent ports.

```bash
./pinggy -p 443 -R0:localhost:8000 udp@free.pinggy.io
```

--------------------------------

### Start HTTP Tunnel with QR Code (No Token)

Source: https://pinggy.io/docs/usages

Starts an HTTP tunnel and displays a QR code in the terminal for easy access. Uses a smaller unicode-based QR code.

```bash
ssh -R0:localhost:<localport> qr@free.pinggy.io
```

--------------------------------

### Serve Files Locally with Node.js

Source: https://pinggy.io/docs/guides/sharefiles

Install and run the http-server package globally to serve files from a specific directory using Node.js. The default port is 8000.

```bash
npm install http-server -g
http-server -p 8000
```

--------------------------------

### Start a Pinggy Tunnel with Auto Reconnection

Source: https://pinggy.io/docs/guides/long_running_tunnels

Use this command to start a Pinggy tunnel. The Pinggy CLI has auto-reconnection built-in. Replace <token> with your actual tunnel token.

```bash
./pinggy -p 443 -R0:localhost:8000 <token>@pro.pinggy.io
```

--------------------------------

### Start UDP Tunnel on macOS/Windows

Source: https://pinggy.io/docs/docker

Use this command to create a UDP tunnel on port 8000 on macOS or Windows. Does not require `--net=host`.

```bash
docker run -it pinggy/pinggy -p 443 -R0:localhost:8080 udp@free.pinggy.io
```

--------------------------------

### Make Startup Script Executable

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

Ensure your Pinggy startup script has execute permissions.

```bash
sudo chmod +x /usr/local/sbin/pinggy-startup.sh

```

--------------------------------

### Start Tunnel with Single IP Whitelist

Source: https://pinggy.io/docs/http_tunnels/ip_whitelist

Use this command to start an SSH tunnel with a single IP address whitelisted. Only connections from this IP will be allowed.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io w:IP1
```

--------------------------------

### Start TLS Tunnel with Single IP Whitelist

Source: https://pinggy.io/docs/tls_tunnels/ip_whitelist

Use this command to start a TLS tunnel that only allows connections from a specific IP address. Replace IP1 with the desired IP.

```bash
ssh -p 443 -R0:localhost:8000 -t tls@free.pinggy.io w:IP1
```

--------------------------------

### Train and Run Rasa Server

Source: https://pinggy.io/docs/guides/rasa_chatbot

Train your Rasa model and start the Rasa server with API enabled. The server will listen on port 5005.

```bash
rasa train
rasa run --enable-api -p 5005
```

--------------------------------

### Add Startup Script to rc.local

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

Add the path to your Pinggy startup script in `/etc/rc.local` before the `exit 0` line.

```bash
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.

/usr/local/sbin/pinggy-startup.sh

exit 0

```

--------------------------------

### Start TLS TCP Tunnel (With Token)

Source: https://pinggy.io/docs/usages

Initiates a TLS TCP tunnel using a token. This is convenient for visitors who can connect via SSL to a TCP-based service.

```bash
ssh -R0:localhost:<localport> <token>+tlstcp@pro.pinggy.io
```

--------------------------------

### Create or Edit rc.local

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

Create or edit the `/etc/rc.local` file to include your startup script.

```bash
sudo nano /etc/rc.local

```

--------------------------------

### Start UDP Tunnel on Linux

Source: https://pinggy.io/docs/docker

Use this command to create a UDP tunnel on port 8000 on Linux. Requires the `--net=host` option.

```bash
docker run --net=host -it pinggy/pinggy -p 443 -R0:localhost:8080 udp@free.pinggy.io
```

--------------------------------

### Enable Basic Authentication with Single Credentials

Source: https://pinggy.io/docs/http_tunnels/basic_auth

Use this command to start a tunnel with a single username and password for basic authentication. Ensure neither the username nor the password contains a colon.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io b:username:password
```

--------------------------------

### Start Pinggy Tunnel

Source: https://pinggy.io/docs/guides/sharefiles

Create a secure tunnel to share your local server. This command establishes a connection to Pinggy's free service, forwarding traffic to your local port 8000.

```bash
ssh -p 443 -R0:localhost:8000 free.pinggy.io
```

--------------------------------

### Mark Tunnel for Auto-Start

Source: https://pinggy.io/docs/cli

Configure a tunnel to automatically start on Pinggy CLI launch. This can be done during saving or as a separate command.

```bash
pinggy config save my-tunnel --auto -l 3000
```

```bash
pinggy config auto my-tunnel
```

--------------------------------

### Start HTTP Tunnel with Web Debugger (SSH)

Source: https://pinggy.io/docs/http_tunnels/web_debugger

Use this SSH command to start an HTTP tunnel and enable the Web Debugger on port 4300. You can change the local port for the debugger by modifying the -L argument.

```bash
ssh -p 443 -R0:localhost:8080 -L4300:localhost:4300 free.pinggy.io
```

--------------------------------

### Start TLSTCP Tunnel with Multiple IP Whitelist

Source: https://pinggy.io/docs/tlstcp_tunnels/ip_whitelist

This command allows you to start a TLSTCP tunnel that accepts connections from multiple specified IP addresses or a CIDR range. Separate multiple IPs with commas. Replace IP1, IP2, IP3.. with the desired IP addresses or ranges.

```bash
ssh -p 443 -R0:localhost:8000 -t tlstcp@free.pinggy.io w:[IP1[,IP2[,IP3..]]]
```

--------------------------------

### Start Tunnel with Multiple IP Whitelist

Source: https://pinggy.io/docs/http_tunnels/ip_whitelist

This command allows you to start an SSH tunnel and whitelist multiple IP addresses or a comma-separated list of IPs. Connections will only be permitted from these specified IPs.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io w:[IP1[,IP2[,IP3..]]]
```

--------------------------------

### Start TLSTCP Tunnel with Single IP Whitelist

Source: https://pinggy.io/docs/tlstcp_tunnels/ip_whitelist

Use this command to start a TLSTCP tunnel that only accepts connections from a single specified IP address. Replace IP1 with the desired IP address.

```bash
ssh -p 443 -R0:localhost:8000 -t tlstcp@free.pinggy.io w:IP1
```

--------------------------------

### Verify Netdata Dashboard Locally

Source: https://pinggy.io/docs/guides/netdata

After installation, confirm that the Netdata dashboard is running locally by querying its API. This ensures the agent is active.

```bash
curl http://localhost:19999/api/v1/info
```

--------------------------------

### Sample URL List Output

Source: https://pinggy.io/docs/api/web_debugger_api

Example JSON output when requesting tunnel URLs from the Pinggy Web Debugger API.

```json
{
  "urls": [
    "http://rnckk-2405-201-9018-a834-e551-ccf2-398f-130d.run.pinggy-free.link",
    "https://rnckk-2405-201-9018-a834-e551-ccf2-398f-130d.run.pinggy-free.link"
  ]
}
```

--------------------------------

### Start Pinggy Tunnel with Options

Source: https://pinggy.io/docs/guides/ssh_mac

This command initiates a Pinggy tunnel with enhanced options for host key checking and keep-alive intervals, forwarding SSH traffic.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -R0:localhost:22 tcp@free.pinggy.io
```

--------------------------------

### Create a Tunnel with Pinggy Node.js SDK

Source: https://pinggy.io/docs

Create and start a tunnel in your Node.js application using the Pinggy SDK. This example forwards traffic to localhost on port 3000.

```javascript
import { pinggy } from "@pinggy/pinggy";


const tunnel = await pinggy.createTunnel({ forwarding: "localhost:3000" });
await tunnel.start();
console.log("Tunnel URLs:", await tunnel.urls()); // Get all public urls
```

--------------------------------

### Sample IP Whitelist Output

Source: https://pinggy.io/docs/api/web_debugger_api

Example JSON output when requesting the IP whitelist from the Pinggy Web Debugger API.

```json
[
  "2205:213:9013:a835:e552:ccf2:398f:1234/128",
  "56.3.51.0/24"
]
```

--------------------------------

### Reboot System

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

Reboot your system to test if the tunnel starts automatically on startup.

```bash
sudo reboot

```

--------------------------------

### Show Help and Exit

Source: https://pinggy.io/docs/cli/index.md

Use this flag to display the help message and exit the application.

```bash
pinggy -h
```

```bash
pinggy --help
```

--------------------------------

### Get Tunnel Session History API Request

Source: https://pinggy.io/docs/api/api

Retrieve a history of your tunnel sessions. This example queries for sessions on a specific date and paginates results. You can query data no older than 60 days. Replace `{API Key}` with your actual API key.

```bash
curl --location 'https://dashboard.pinggy.io/backend/api/v1/session/history/2025-02-06/2025-02-06?page=0&size=10' \
--header 'Authorization: Bearer {API Key}'
```

--------------------------------

### Start TCP Tunnel With Token

Source: https://pinggy.io/docs/usages

Initiates a TCP tunnel with a token, enabling raw TCP data forwarding with authentication. Replace `<token>` with your actual Pinggy token. This also supports IP whitelisting.

```bash
ssh -R0:localhost:<localport> <token>+tcp@pro.pinggy.io
```

--------------------------------

### Start TCP Tunnel with Multiple IP Whitelist

Source: https://pinggy.io/docs/tcp_tunnels/ip_whitelist

This command allows you to specify multiple IP addresses for whitelisting. Connections will only be accepted from the listed IPs. Replace IP1, IP2, etc., with the actual IP addresses.

```bash
ssh -p 443 -R0:localhost:8000 -t tcp@free.pinggy.io w:[IP1[,IP2[,IP3..]]]
```

--------------------------------

### Enable Web Debugger on Linux

Source: https://pinggy.io/docs/docker

This command starts an HTTP tunnel and enables the Web Debugger on port 4300 on Linux. Requires the `--net=host` option.

```bash
docker run --net=host -it pinggy/pinggy -p 443 -R0:localhost:8080 -L4300:localhost:4300 free.pinggy.io
```

--------------------------------

### Enable Detailed Logs (SDK + Libpinggy)

Source: https://pinggy.io/docs/cli/index.md

Use this flag for more detailed logs, including output from the Node.js SDK and Libpinggy.

```bash
pinggy --vv
```

--------------------------------

### Start TCP Tunnel with CIDR IP Whitelist

Source: https://pinggy.io/docs/tcp_tunnels/ip_whitelist

This command demonstrates how to use CIDR notation to specify a range of IP addresses for whitelisting. This is useful for allowing access from a subnet. Replace 54.88.149.108/24 with your desired CIDR block.

```bash
ssh -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 -t -R0:localhost:8000 tcp@free.pinggy.io "w:54.88.149.108/24"
```

--------------------------------

### Specify Local Endpoint

Source: https://pinggy.io/docs/cli/index.md

Use this flag to define the local endpoint, including protocol, host, and port. Example: `[protocol:][host:]port`.

```bash
pinggy --localport https://localhost:8000
```

--------------------------------

### Start TLS Tunnel (No Token)

Source: https://pinggy.io/docs/usages

Initiates a TLS tunnel without requiring a token. The server forwards incoming SSL/TLS traffic based on SNI.

```bash
ssh -R0:localhost:<localport> tls@free.pinggy.io
```

--------------------------------

### Check and Enable rc.local Service (systemd)

Source: https://pinggy.io/docs/run_tunnel_on_startup/rc_local

For systems using `systemd`, check the status of `rc-local.service` and enable/start it if necessary.

```bash
sudo systemctl status rc-local.service
# If it is not running, try:
sudo systemctl enable rc-local.service
sudo systemctl start rc-local.service

```

--------------------------------

### Start TLS TCP Tunnel (No Token)

Source: https://pinggy.io/docs/usages

Establishes a TLS TCP tunnel without a token. This provides a TCP port for incoming connections and an optional TLS URL for SSL termination.

```bash
ssh -R0:localhost:<localport> tlstcp@free.pinggy.io
```

--------------------------------

### Enable Web Debugger on macOS/Windows

Source: https://pinggy.io/docs/docker

This command starts an HTTP tunnel and enables the Web Debugger on port 4300 on macOS or Windows. Requires port mapping and uses `0.0.0.0` for the local address.

```bash
docker run -p 4300:4300 -it pinggy/pinggy -p 443 -R0:localhost:8080 -L0.0.0.0:4300:localhost:4300 free.pinggy.io
```

--------------------------------

### Serve Files from Local Directory

Source: https://pinggy.io/docs/cli/index.md

Use this flag to serve files from a local directory using a simple web server. Specify the path to the directory.

```bash
pinggy --serve <path>
```

--------------------------------

### Example Response for Active Tunnels

Source: https://pinggy.io/docs/api/api

This is an example of the JSON response you will receive when listing active tunnels. It includes details about each tunnel session.

```json
[
    {
        "id": "9345b393-d916-4a2e-816a-3347468a03c0",
        "userId": 4490909,
        "tokenId": 392084,
        "token": null,
        "tokenName": null,
        "virtualToken": "sJsufpgMMl-10003",
        "virtualTokenName": null,
        "subdomain": "mytest.v.awesomeapp.a.pinggy.link",
        "customdomain": null,
        "mode": "tcp",
        "modeUdp": "",
        "port": 10003,
        "creationTimestamp": "2024-08-23T04:04:36.083+00:00",
        "lastUpdateTimestamp": "2024-08-23T04:04:37.780+00:00"
    }
]
```

--------------------------------

### Create Systemd Service File

Source: https://pinggy.io/docs/run_tunnel_on_startup/linux

Create a systemd service unit file to manage the Pinggy tunnel startup script. This file defines how the service runs and restarts.

```bash
sudo nano /etc/systemd/system/pinggy-startup.service
```

--------------------------------

### Reload Systemd and Manage Pinggy Service

Source: https://pinggy.io/docs/run_tunnel_on_startup/linux

Reload the systemd daemon to recognize the new service, enable it to start on boot, and start it immediately.

```bash
sudo systemctl daemon-reload
sudo systemctl enable pinggy-startup.service
sudo systemctl start pinggy-startup.service
```

--------------------------------

### Combine Header Update and Removal

Source: https://pinggy.io/docs/advanced/live_header

This command updates the 'Host' header to 'example.com' and simultaneously removes the 'Referer' header from incoming requests.

```bash
ssh -p 443 -R0:localhost:8080 -t free.pinggy.io u:Host:example.com r:Referer
```

--------------------------------

### Load Configuration from File

Source: https://pinggy.io/docs/cli

Loads Pinggy configuration from a specified JSON file and overrides specific flags.

```bash
pinggy --conf ./myconfig.json -p 8080
```

--------------------------------

### Get Tunnel URLs Programmatically

Source: https://pinggy.io/docs/http_tunnels/web_debugger

Send a GET request to this endpoint to retrieve a list of available tunnel URLs. This is useful for integrating with other applications.

```json
{
  "urls": [
    "http://rnckk-23.4.5.6.run.pinggy-free.link",
    "https://rnckk-23.4.5.6.run.pinggy-free.link"
  ]
}
```

--------------------------------

### Enable Verbose Logs (CLI, SDK, Libpinggy)

Source: https://pinggy.io/docs/cli/index.md

Use this flag to enable the most verbose logging, including logs from the CLI, SDK, and Libpinggy.

```bash
pinggy --vvv
```

--------------------------------

### Set Basic Authentication

Source: https://pinggy.io/docs/usages

Configures basic username-password authentication for visitors. This prompt appears in the browser.

```bash
b:username:password
```

--------------------------------

### Make Shell Script Executable

Source: https://pinggy.io/docs/run_tunnel_on_startup/linux

Grant execute permissions to the Pinggy startup script. This is required for the systemd service to run the script.

```bash
sudo chmod +x /usr/local/sbin/pinggy-startup.sh
```

--------------------------------

### Get IP Whitelist

Source: https://pinggy.io/docs/api/web_debugger_api

Retrieve the list of currently whitelisted IP addresses for a tunnel by sending a GET request to the /ipwhitelist endpoint. This applies to various tunnel types.

```bash
curl http://localhost:4300/ipwhitelist
```

--------------------------------

### Example Response for Tunnel Session History

Source: https://pinggy.io/docs/api/api

This is an example of the JSON response for tunnel session history. It includes pagination details and a list of past tunnel sessions with their associated information.

```json
{
  "totalElements": 1,
  "totalPages": 1,
  "size": 10,
  "content": [
    {
      "start_time": "2025-02-06T16:16:44.571+00:00",
      "end_time": "2025-02-07T06:15:26.294+00:00",
      "user_email": "youremail@example.com",
      "token_value": "AAXXYY99F",
      "virtual_token_value": null,
      "domains": [
        "test.example.com",
        "test.a.pinggy.link"
      ],
      "mode": "http",
      "mode_udp": "",
      "client_ip": "[5.7.152.215]:48696",
      "port": null
    }
  ],
  "number": 0,
  "sort": {
    "empty": true,
    "sorted": false,
    "unsorted": true
  },
  "pageable": {
    "pageNumber": 0,
    "pageSize": 10,
    "sort": {
      "empty": true,
      "sorted": false,
      "unsorted": true
    },
    "offset": 0,
    "paged": true,
    "unpaged": false
  },
  "numberOfElements": 1,
  "first": true,
  "last": true,
  "empty": false
}
```

--------------------------------

### Get List of Tunnel URLs

Source: https://pinggy.io/docs/api/web_debugger_api

Retrieve a list of all active tunnel URLs by sending a GET request to the /urls endpoint of the Web Debugger. This works for various tunnel types.

```bash
curl http://localhost:4300/urls
```

--------------------------------

### Enable Basic Authentication with Multiple Credentials

Source: https://pinggy.io/docs/http_tunnels/basic_auth

This command allows you to configure multiple username:password combinations for basic authentication, providing flexibility for different users.

```bash
ssh -p 443 -R0:localhost:8000 -t free.pinggy.io b:username1:password1 b:username2:password2
```

--------------------------------

### Start TCP Tunnel Without Token

Source: https://pinggy.io/docs/usages

Starts a TCP tunnel without a token, forwarding raw TCP data. This is useful for non-HTTP services where no processing is needed. IP whitelisting is available for TCP tunnels.

```bash
ssh -R0:localhost:<localport> tcp@free.pinggy.io
```

--------------------------------

### Log to File and Stdout

Source: https://pinggy.io/docs/cli

Configures logging to a file and stdout at the INFO level, with a specific server port.

```bash
pinggy -p 3000 --logfile ~/.pinggy/pinggy.log --loglevel INFO --v
```

--------------------------------

### Basic Pinggy CLI Syntax

Source: https://pinggy.io/docs/cli

The fundamental syntax for using the Pinggy CLI, including optional user and domain parameters.

```bash
pinggy [options] [user@domain]
```

--------------------------------

### Get tunnel session history

Source: https://pinggy.io/docs/api/api

Retrieves a history of all tunnels created from your account. Data is available for no older than 60 days. Supports pagination.

```APIDOC
## Get tunnel session history

### Description
Get a history of all tunnels created from your account. You can query data no older than 60 days.

### Method
GET

### Endpoint
https://dashboard.pinggy.io/backend/api/v1/session/history/{startDate}/{endDate}

### Parameters
#### Path Parameters
- **startDate** (string) - Required - The start date for the history query (YYYY-MM-DD).
- **endDate** (string) - Required - The end date for the history query (YYYY-MM-DD).

#### Query Parameters
- **page** (integer) - Optional - The page number for pagination (defaults to 0).
- **size** (integer) - Optional - The number of items per page (defaults to 10).

#### Headers
- **Authorization** (string) - Required - Bearer {API Key}

### Response
#### Success Response (200)
- **totalElements** (integer) - The total number of elements found.
- **totalPages** (integer) - The total number of pages available.
- **size** (integer) - The number of elements per page.
- **content** (array) - An array of tunnel session history objects.
  - **start_time** (string) - The start time of the tunnel session.
  - **end_time** (string) - The end time of the tunnel session.
  - **user_email** (string) - The email of the user who created the tunnel.
  - **token_value** (string) - The value of the token used.
  - **virtual_token_value** (string) - The virtual token value (may be null).
  - **domains** (array of strings) - A list of domains associated with the tunnel.
  - **mode** (string) - The mode of the tunnel (e.g., "http").
  - **mode_udp** (string) - The UDP mode of the tunnel (if applicable).
  - **client_ip** (string) - The client IP address and port.
  - **port** (integer) - The port number used by the tunnel (may be null).
- **number** (integer) - The current page number.
- **sort** (object) - Information about sorting.
- **pageable** (object) - Information about pagination.
- **numberOfElements** (integer) - The number of elements in the current page.
- **first** (boolean) - Indicates if this is the first page.
- **last** (boolean) - Indicates if this is the last page.
- **empty** (boolean) - Indicates if the response is empty.

### Request Example
```bash
curl --location 'https://dashboard.pinggy.io/backend/api/v1/session/history/2025-02-06/2025-02-06?page=0&size=10' \
--header 'Authorization: Bearer {API Key}'
```

### Response Example
```json
{
  "totalElements": 1,
  "totalPages": 1,
  "size": 10,
  "content": [
    {
      "start_time": "2025-02-06T16:16:44.571+00:00",
      "end_time": "2025-02-07T06:15:26.294+00:00",
      "user_email": "youremail@example.com",
      "token_value": "AAXXYY99F",
      "virtual_token_value": null,
      "domains": [
        "test.example.com",
        "test.a.pinggy.link"
      ],
      "mode": "http",
      "mode_udp": "",
      "client_ip": "[5.7.152.215]:48696",
      "port": null
    }
  ],
  "number": 0,
  "sort": {
    "empty": true,
    "sorted": false,
    "unsorted": true
  },
  "pageable": {
    "pageNumber": 0,
    "pageSize": 10,
    "sort": {
      "empty": true,
      "sorted": false,
      "unsorted": true
    },
    "offset": 0,
    "paged": true,
    "unpaged": false
  },
  "numberOfElements": 1,
  "first": true,
  "last": true,
  "empty": false
}
```
```

--------------------------------

### Save a Tunnel Configuration

Source: https://pinggy.io/docs/cli

Save the current tunnel configuration with a given name for later use. This example saves a tunnel to port 3000 with authentication.

```bash
pinggy config save my-tunnel -l 3000 token@pro.pinggy.io
```

--------------------------------

### Get IP whitelist

Source: https://pinggy.io/docs/api/web_debugger_api

Retrieves the list of IP addresses that are currently whitelisted for access to the tunnel. This allows for IP-based access control to your exposed services.

```APIDOC
## GET /ipwhitelist

### Description
Retrieves the list of whitelisted IP addresses for the tunnel.

### Method
GET

### Endpoint
`http://localhost:4300/ipwhitelist`

### Parameters
None

### Request Example
```bash
curl http://localhost:4300/ipwhitelist
```

### Response
#### Success Response (200)
- (array) - A list of strings, where each string represents a whitelisted IP address or CIDR block.

#### Response Example
```json
[
  "2205:213:9013:a835:e552:ccf2:398f:1234/128",
  "56.3.51.0/24"
]
```
```

--------------------------------

### SSH into IoT Device using Persistent URL (Pro)

Source: https://pinggy.io/docs/guides/ssh_iot

Connect to your IoT device using the persistent public URL and port provided by Pinggy Pro. Replace 'username' with your device's username.

```bash
ssh -p 43142 username@myraspberrypi.a.pinggy.link
```

--------------------------------

### Get the list of URLs / addresses

Source: https://pinggy.io/docs/api/web_debugger_api

Retrieves a list of all active tunnel URLs associated with the current session. This is useful for accessing your exposed services programmatically.

```APIDOC
## GET /urls

### Description
Retrieves a list of tunnel URLs.

### Method
GET

### Endpoint
`http://localhost:4300/urls`

### Parameters
None

### Request Example
```bash
curl http://localhost:4300/urls
```

### Response
#### Success Response (200)
- **urls** (array) - A list of strings, where each string is a tunnel URL.

#### Response Example
```json
{
  "urls": [
    "http://rnckk-2405-201-9018-a834-e551-ccf2-398f-130d.run.pinggy-free.link",
    "https://rnckk-2405-201-9018-a834-e551-ccf2-398f-130d.run.pinggy-free.link"
  ]
}
```
```

--------------------------------

### Create a Tunnel with Pinggy Python SDK

Source: https://pinggy.io/docs

Start an HTTP tunnel in your Python application using the Pinggy SDK, forwarding traffic to localhost on port 8000.

```python
import pinggy

# Start an HTTP tunnel forwarding traffic to localhost on port 8000
tunnel = pinggy.start_tunnel(forwardto="localhost:8000")

print(f"Tunnel started. Urls: {tunnel.urls}")
```
Tokens:
Raw