Tenzro Network

Peer-to-peer networking platform for connecting devices globally. Secure, decentralized mesh networking with 15,678 connected devices across 12 bootstrap nodes.

Key Features

One-Command Connection

Connect any device to the global P2P network with a single command or Docker container

3-second setup with automatic configuration

Global P2P Network

Decentralized mesh networking with 15,678 total devices and automatic peer discovery

Connect 150 nodes across multiple regions

End-to-End Encryption

TLS 1.3 + libp2p noise protocol for secure device-to-device communications

Military-grade encryption with zero trust

NAT Traversal & Relay

Automatic firewall bypass with intelligent relay fallback and cross-platform support

Works behind any firewall with 12 bootstrap nodes

Bootstrap Node Redundancy

GKE bootstrap cluster with regional distribution for high availability

us-central1, us-west1, europe-west4 regions

Real-time Monitoring

Track device status, connection health, and network performance metrics

Live device management and analytics

Code Examples

Device Connection

Connect Device to P2P Networkjavascript
// Connect device to Tenzro P2P Network
const response = await fetch('https://api.tenzro.com/network/connect', {
  method: 'POST',
  headers: {
    'X-API-Key': 'sk_your_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    device_name: "my-laptop",
    location: "home-office-san-francisco"
  })
});

const connection = await response.json();
console.log('Device ID:', connection.device_id);
console.log('Virtual IP:', connection.virtual_ip);
console.log('Network Token:', connection.network_token);

// Network configuration details
console.log('Virtual Subnet:', connection.network_info.virtual_subnet);
console.log('Bootstrap Nodes:', connection.network_info.bootstrap_nodes);
console.log('Discovery Methods:', connection.network_info.discovery_methods);
console.log('Encryption:', connection.network_info.encryption);

// Installation options
console.log('One-liner install:', connection.connect_command);
console.log('Docker command:', connection.docker_command);
console.log('Install script URL:', connection.install_script);

// Example output:
// Device ID: dev_abc123
// Virtual IP: 10.20.30.45
// Virtual Subnet: 10.20.0.0/16
// Bootstrap Nodes: ["bootstrap-us-central1.tenzro.com:4001", ...]
// Discovery Methods: ["mdns", "dht", "bootstrap"]

Quick Connect

Ultra-Fast Device Connectionjavascript
// Ultra-quick connection with auto-generated device name
const quickResponse = await fetch('https://api.tenzro.com/network/quick-connect', {
  method: 'POST',
  headers: {
    'X-API-Key': 'sk_your_key_here',
    'Content-Type': 'application/json'
  }
});

const quickConnection = await quickResponse.json();
console.log('Quick connect one-liner:', quickConnection.one_liner);
console.log('Device info:', quickConnection.device_info);
console.log('Network status URL:', quickConnection.network_status);

// Example one-liner output:
// curl -sSL https://install.tenzro.com/p2p | bash -s -- --token dGVuenJvX25ldHdvcmtfdG9rZW5fZGVmNDU2

// Device info:
// {
//   "device_id": "dev_def456",
//   "device_name": "device-2025-05-29-001", 
//   "virtual_ip": "10.20.30.46"
// }

Device Management

Manage Connected Devicesjavascript
// List all connected devices with detailed status
const devicesResponse = await fetch('https://api.tenzro.com/network/devices', {
  headers: { 'X-API-Key': 'sk_your_key_here' }
});

const deviceList = await devicesResponse.json();
console.log('Total devices:', deviceList.total);

deviceList.devices.forEach(device => {
  console.log(`Device: ${device.device_name}`);
  console.log(`  ID: ${device.device_id}`);
  console.log(`  Virtual IP: ${device.virtual_ip}`);
  console.log(`  Status: ${device.status}`);
  console.log(`  Location: ${device.location}`);
  console.log(`  Connection Type: ${device.connection_type}`);
  console.log(`  Latency: ${device.latency_ms}ms`);
  console.log(`  Uptime: ${device.uptime_hours}h`);
  console.log(`  Peer ID: ${device.peer_id}`);
});

// Get specific device status
const deviceStatus = await fetch('https://api.tenzro.com/network/devices/dev_abc123', {
  headers: { 'X-API-Key': 'sk_your_key_here' }
});

const device = await deviceStatus.json();
console.log('Device details:', device);

// Get comprehensive network status
const networkStatus = await fetch('https://api.tenzro.com/network/status', {
  headers: { 'X-API-Key': 'sk_your_key_here' }
});

const status = await networkStatus.json();
console.log('Network Status:');
console.log(`  Total devices: ${status.total_devices}`);
console.log(`  Bootstrap nodes: ${status.bootstrap_nodes}`);
console.log(`  Network health: ${status.network_health}`);
console.log(`  Uptime: ${status.uptime_hours}h`);
console.log(`  Virtual subnet: ${status.virtual_subnet}`);
console.log(`  Discovery methods: ${status.discovery_methods.join(", ")}`);

// Disconnect a device
const disconnectResponse = await fetch('https://api.tenzro.com/network/devices/dev_abc123', {
  method: 'DELETE',
  headers: { 'X-API-Key': 'sk_your_key_here' }
});

const disconnectResult = await disconnectResponse.json();
console.log(disconnectResult.message);

Use Cases

IoT Device Connectivity

Connect sensors, cameras, and IoT devices to a secure global mesh network

Smart home automation, industrial sensors, security cameras, environmental monitoring

  • Secure device-to-device communication
  • No port forwarding required
  • Global accessibility

Remote Development & Server Access

Secure access to development environments, home labs, and remote servers

Development servers, staging environments, home lab access, remote workstations

  • Zero-config VPN alternative
  • Direct peer connections
  • Low latency access

Edge Computing Networks

Create distributed computing networks across edge devices and locations

CDN nodes, edge AI processing, distributed databases, microservice meshes

  • Automatic service discovery
  • Load balancing
  • Fault tolerance

Gaming & Entertainment

Low-latency P2P connections for multiplayer gaming and content sharing

Private game servers, tournaments, LAN parties, content distribution

  • Sub-20ms latency
  • Direct peer connections
  • No bandwidth limits

Secure File Sharing

Direct device-to-device file transfer without cloud intermediaries

Enterprise file sharing, backup synchronization, content collaboration

  • End-to-end encryption
  • No cloud storage needed
  • Unlimited file sizes

Remote Work Connectivity

Seamless access to office resources from any location

Office printer access, internal tools, shared drives, development environments

  • VPN-free connectivity
  • Office-like experience
  • Secure communications

Network Architecture

Bootstrap Nodes

12
GKE-powered global discovery

Connected Devices

15,678
Devices worldwide

Virtual Subnet

10.20.0.0/16
Private address space

Network Uptime

8,760h
Continuous operation

Bootstrap Node Locations

us-central1
bootstrap-us-central1.tenzro.com:4001
us-west1
bootstrap-us-west1.tenzro.com:4001
europe-west4
bootstrap-europe-west4.tenzro.com:4001

Quick Start

1. Get Your Connection Token

javascript
// Get connection token from API
const response = await fetch('https://api.tenzro.com/network/quick-connect', {
  method: 'POST',
  headers: {
    'X-API-Key': 'sk_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const { one_liner, device_info } = await response.json();
console.log('One-liner command:', one_liner);
console.log('Device ID:', device_info.device_id);

2. Connect Your Device (Option 1: Direct Install)

bash
curl -sSL https://install.tenzro.com/p2p | bash -s -- --token YOUR_TOKEN

2. Connect Your Device (Option 2: Docker)

bash
docker run -d --name tenzro-p2p --network host \
  -e TENZRO_TOKEN=YOUR_TOKEN \
  tenzro/p2p:latest

3. Verify Connection

javascript
// Check device status
const status = await fetch('https://api.tenzro.com/network/devices', {
  headers: { 'X-API-Key': 'sk_your_api_key_here' }
});

const devices = await status.json();
console.log('Connected devices:', devices.total);

// Your device should appear in the list with status "online"

Security & Privacy

End-to-End Encryption

All device-to-device communications use TLS 1.3 and libp2p noise protocol for maximum security.

  • TLS 1.3 + libp2p noise protocol
  • Perfect forward secrecy
  • Hardware-verified connections
  • Zero-knowledge architecture

Decentralized Architecture

No central authority or single point of failure. Direct peer-to-peer communication.

  • No central servers for data
  • Direct peer-to-peer connections
  • Automatic NAT traversal
  • Bootstrap node redundancy

Protocols & Standards

libp2p

Modular P2P networking stack

mDNS

Local network discovery

DHT

Distributed hash table

Bootstrap

Initial network discovery

Discovery Methods: mDNS (local), DHT (distributed), Bootstrap nodes (global), Relay (fallback)

Performance Metrics

< 3s
Connection Setup
< 50ms
Peer Discovery
1Gbps+
Direct Throughput
99.9%
NAT Success

Live Demo

🌐 Tenzro P2P Network

Overview

  • • Peer-to-peer networking for any device
  • • LibP2P + EdgeVPN + GKE Bootstrap Cluster
  • • Decentralized with bootstrap nodes

Features

  • • 🔧 One-command device connection
  • • 🌍 Global P2P network (15,678 devices)
  • • 🔒 End-to-end encrypted connections
  • • 📱 Support for any device type

Getting Started

1. Quick Connect: POST /network/quick-connect
2. Get Command: Copy the one_liner from response
3. Run Command: Paste and run on your device
4. Verify: Device joins decentralized network

Use Cases

IoT connectivity • Remote server access • Edge computing • Gaming networks • Secure file sharing • Remote work

Connection Steps

1

Get Connection Token

Call /network/quick-connect API to get your device connection token

curl -X POST https://api.tenzro.com/network/quick-connect
2

Install P2P Client

Run the one-liner install script or use Docker on your device

curl -sSL https://install.tenzro.com/p2p | bash -s -- --token TOKEN
3

Join Global Network

Your device automatically joins the mesh with virtual IP assignment

Virtual IP: 10.20.30.XX assigned from 10.20.0.0/16