Documentación

Introducción

dtunnel es un túnel HTTP/HTTPS tipo ngrok o Tunnelmole, alojado en dtunnel.desarrollado.com. Tu aplicación sigue escuchando en localhost; el cliente dtunnel mantiene una conexión saliente hacia el servidor y enruta el tráfico de Internet hacia tu proceso local.

Funciona con cualquier stack que escuche en un puerto TCP local:

• Servidores de desarrollo: Vite, Next.js, Create React App, Flask, Django, etc.
• APIs REST y GraphQL
• Contenedores Docker con -p 8080:80 mapeado a localhost
• Nginx o Apache en tu máquina
• WebSockets (WSS) a través del túnel HTTPS

Requisitos

Instalación

Plataforma web/API: … · CLI npm: … · Comprueba con dtunnel version

Instalador universal (Linux, macOS y WSL)

Requiere Node.js 18+. Instala el paquete npm global (túnel nativo, sin frpc):

curl -O https://install.desarrollado.com/dtunnel/install && sudo bash install

Opcionalmente, audita el script antes de ejecutarlo:

curl https://install.desarrollado.com/dtunnel/install

Espejo alternativo:

curl -O https://dtunnel.desarrollado.com/install/dtunnel/install && sudo bash install

Instalar con Node.js (recomendado)

La mejor opción para desarrolladores y Windows. v2 no descarga binarios externos.

npm install -g @desarrollado/dtunnel

Paquete en npmjs.com/@desarrollado/dtunnel (v…).

Comprueba la instalación:

dtunnel version
dtunnel --help

Actualizar dtunnel

Consulta el changelog para ver qué incluye cada versión.

Primero comprueba qué versión tienes instalada:

dtunnel version

Versión publicada de la plataforma: … · CLI: …

Linux / macOS / WSL (instalador curl)

Vuelve a ejecutar el instalador (actualiza el paquete npm global):

curl -O https://install.desarrollado.com/dtunnel/install && sudo bash install
dtunnel version

Node.js / npm

npm install -g @desarrollado/dtunnel@latest
dtunnel version

Para instalar una versión concreta:

npm install -g @desarrollado/dtunnel@…

Windows sin WSL

Usa npm (arriba). Modo legacy con frpc: dtunnel --frp --port PUERTO o dtunnel install-frpc.

Inicio rápido

1. Levanta tu app local en un puerto, por ejemplo 88080:

   python -m http.server 88080
   # o: npm run dev  →  suele ser puerto 3000, 5173, etc.

2. Abre el túnel (URL aleatoria, plan gratuito):

   dtunnel --port 88080

   Salida esperada:

   https://a7f3c2.dtunnel.desarrollado.com  ⟶  http://localhost:88080
   http://a7f3c2.dtunnel.desarrollado.com   ⟶  http://localhost:88080

3. Prueba desde el navegador o con curl:

   curl -I https://a7f3c2.dtunnel.desarrollado.com

4. Detén el túnel cuando termines:

   dtunnel down

Docker y otros hostnames

Por defecto el túnel reenvía a 127.0.0.1:PUERTO. Si tu app no escucha en localhost (p. ej. un servicio de Docker Compose llamado mi-proyecto), indica el host:

dtunnel --port 3000 --host mi-proyecto
# o de forma persistente:
dtunnel config set localHost mi-proyecto
dtunnel --port 3000

El CLI debe poder resolver ese nombre (misma red Docker, entrada en /etc/hosts, etc.). Comprueba con curl http://mi-proyecto:3000 desde la máquina donde corre dtunnel.

Next.js (dev con basePath)

Si tu app usa basePath: '/portal-pmo-frontend', abre la URL con ese prefijo:

https://TU-SUBDOMINIO.dtunnel.desarrollado.com/portal-pmo-frontend

La raíz / devolverá 404 — es normal si Next solo vive bajo el basePath.

En modo desarrollo (next dev), dtunnel elimina automáticamente cabeceras como Origin al reenviar a tu localhost, para que Next.js no bloquee los assets (no hace falta allowedDevOrigins en la mayoría de casos).

Si usas basePath, abre la URL con ese prefijo. El hot-reload (HMR) usa WebSocket y está soportado desde el CLI 2.0.9 (Next.js next dev, Vite, NestJS WS).

En el otro PC:

dtunnel --port 3000
dtunnel status   # debe mostrar el túnel activo
curl http://127.0.0.1:3000/portal-pmo-frontend   # debe responder antes del túnel

Referencia CLI

Archivos locales del cliente:

• ~/.dtunnel/config.json — token de sesión (si hiciste login)
• ~/.dtunnel/tunnel.json — estado del túnel activo (subdominio, URLs, PID)
• ~/.dtunnel/tunnel.pid — PID del proceso del túnel (v2 nativo)
• ~/.dtunnel/frpc.toml — solo modo legacy --frp
• ~/.dtunnel/bin/frpc — solo modo legacy

Cuentas, subdominios y reservas

En dtunnel conviven tres ideas distintas. Mezclarlas es la causa más habitual de errores («subdominio no reservado», «404 en la URL», etc.).

Tres conceptos (no son lo mismo)

Sin cuenta (gratis)

dtunnel --port 80
# → https://c349cc8e.dtunnel.desarrollado.com  (nombre aleatorio)

• Cada vez que abres un túnel obtienes un subdominio aleatorio.
• No puedes elegir el nombre ni reutilizarlo en otra sesión.
• Al hacer dtunnel down el túnel se cierra; la URL deja de funcionar.
• No existe el comando reserve sin cuenta.

Con cuenta: dos pasos separados

Para tener siempre la misma URL necesitas reservar el nombre una vez y abrir el túnel cuando quieras usarlo. Son acciones distintas.

Paso 1 — Reservar el nombre (una sola vez)

dtunnel register          # o dtunnel login
dtunnel reserve mi-api    # guarda "mi-api" en tu cuenta — NO abre túnel

También puedes reservar desde el panel web tras iniciar sesión · olvidé mi contraseña. En este punto https://mi-api.dtunnel.desarrollado.com aún no responde: solo has reclamado el nombre.

Paso 2 — Abrir el túnel con ese nombre

dtunnel --port 3000 --subdomain mi-api
# → https://mi-api.dtunnel.desarrollado.com  ⟶  http://localhost:3000

Aquí sí se crea el túnel activo. Mientras el CLI esté en marcha (o el proceso en segundo plano siga vivo), la URL pública apunta a tu máquina. Al cerrar con dtunnel down la URL deja de responder, pero la reserva de mi-api sigue en tu cuenta para la próxima vez.

Reserva vs túnel activo

Dos límites distintos (con cuenta)

No confundas cuántos nombres puedes guardar con cuántas conexiones puedes tener abiertas a la vez:

Puedes reservar varios nombres (mi-api, staging, demo…) y usar uno u otro al abrir cada túnel con -s. Ver también Límites y planes.

Reglas de nombres

• Longitud: 3–32 caracteres
• Solo letras minúsculas, números y guiones (a-z, 0-9, -)
• Bloqueados para todos: www, api, admin, mail, ftp, dtunnel
• Primero en reservar gana el nombre (mientras la cuenta esté activa)

Flujo completo de referencia

# Día 1 — configuración inicial
dtunnel register
dtunnel reserve mi-api

# Cada vez que quieras exponer tu app
dtunnel --port 3000 --subdomain mi-api
# … trabajas con la misma URL …
dtunnel down

# Día 2 — la reserva sigue; solo abres de nuevo
dtunnel --port 3000 --subdomain mi-api

Studio, Alojamiento y Recursos

Además del túnel desde tu PC, dtunnel ofrece un IDE en el navegador y despliegue persistente en el VPS. Son productos separados del plan de túneles CLI.

Studio (abrir)

• Editor de archivos con explorador, pestañas y terminal integrada (comandos permitidos: npm, node, etc.).
• Plantillas — 40 landing pages del artículo 40 Free HTML landing page templates (DEV / Cruip).
• Preview temporal — URL st-*.dtunnel mientras la pestaña del Studio esté abierta.
• Importar desde Git (HTTPS o SSH), buscar en archivos (Ctrl+Shift+F), renombrar (F2).

Alojamiento 24/7 (panel)

• Apps Node.js persistentes con subdominio h-*.dtunnel.desarrollado.com.
• Flujo: edita en Studio → crea una app en Alojamiento → Desplegar desde Studio.
• Métricas de disco, RAM, tráfico y visor de logs en el dashboard.
• Plan Pro incluye 1 app; Equipo incluye 3. Más slots en Recursos.

Recursos add-on (catálogo)

• Amplía capacidad sin cambiar de plan de túneles: slots de alojamiento, +GB Studio, +GB hosting, RAM, tráfico.
• Los medidores de uso muestran consumo actual vs. límite contratado.
• Checkout con Wompi; tras el pago vuelves a Recursos para ver el add-on activo.

App móvil Android

dtunnel beta desarrollado — app para gestionar tu cuenta desde el móvil (com.desarrollado.dtunnel). Incluye dashboard, subdominios, billing, CNAME y soporte. Studio y terminal solo en desktop.

Instalación

Chainlist — redes blockchain EVM

dtunnel Chainlist es un catálogo de redes EVM con Chain ID, exploradores, endpoints RPC, medición de latencia y exploración on-chain. Los datos provienen de chainid.network (misma fuente que chainlist.org).

URLs

Funciones

• RPC y latencia — /chain/{id}/probe?format=json mide latencia y score de cada endpoint HTTP.
• Explorar on-chain — /chain/{id}/explore?q=… acepta hash de tx, dirección, contrato o número de bloque.
• MetaMask — botón para añadir la red al wallet desde la ficha de cada cadena.
• Copiar RPC — lista de endpoints con un clic para pegar en tu dApp o wallet.

Ejemplos

# JSON de Arbitrum One
curl "https://chainlist.dtunnel.desarrollado.com/chain/42161?format=json"

# Probe de latencia RPC
curl "https://chainlist.dtunnel.desarrollado.com/chain/42161/probe?format=json"

# Buscar redes con "polygon"
curl "https://chainlist.dtunnel.desarrollado.com/?q=polygon&format=json"

Casos de uso

React / Vite / Next.js

npm run dev          # anota el puerto (ej. 5173)
dtunnel --port 5173

Node.js / Express

node server.js       # escucha en 3000
dtunnel --port 3000

Docker

Publica el puerto en localhost y tunela ese puerto:

docker run -p 8080:80 nginx:alpine
dtunnel --port 8080

Webhooks (Stripe, GitHub, IFTTT…)

Configura la URL del webhook como https://<tu-sub>.dtunnel.desarrollado.com/ruta. El proveedor enviará POST/GET a tu app local a través del túnel.

Probar en móvil o con un compañero

Comparte la URL HTTPS que imprime el CLI. Cualquier dispositivo con Internet puede acceder mientras el túnel esté activo en tu máquina.

WebSocket (WSS)

Las apps que usan wss:// sobre la misma URL HTTP funcionan sin configuración adicional en el cliente dtunnel; el tráfico pasa por el túnel HTTPS.

API REST

Base URL: https://dtunnel.desarrollado.com/api

Salud del servicio

GET /api/health
# → { "ok": true, "service": "dtunnel-api" }

Registro e inicio de sesión

POST /api/auth/register
Content-Type: application/json
{ "email": "tu@email.com", "password": "minimo8chars" }

POST /api/auth/login
{ "email": "tu@email.com", "password": "..." }
# → { "token": "...", "email": "...", "isAdmin": false }

POST /api/auth/forgot-password
{ "email": "tu@email.com" }
# → { "ok": true, "message": "..." }  (siempre 200 si el formato es válido)

POST /api/auth/change-password
Authorization: Bearer <token>
{ "currentPassword": "...", "password": "nuevaMin8" }

POST /api/auth/reset-password
{ "token": "...", "password": "minimo8chars" }

Crear túnel

POST /api/tunnels
Content-Type: application/json
{ "port": 88080 }

# Con cuenta (header Authorization: Bearer <token>)
{ "port": 3000, "subdomain": "mi-api" }

# Respuesta
{
  "subdomain": "a7f3c2",
  "httpUrl": "http://a7f3c2.dtunnel.desarrollado.com",
  "httpsUrl": "https://a7f3c2.dtunnel.desarrollado.com",
  "server": "dtunnel.desarrollado.com",
  "serverPort": 7000,
  "token": "...",
  "persistent": false
}

Reservar subdominio

POST /api/subdomains/reserve
Authorization: Bearer <token>
{ "name": "mi-api" }

GET /api/me
Authorization: Bearer <token>
# → { "email": "...", "subdomains": ["mi-api"], "limits": { ... } }

GET /api/tunnels
Authorization: Bearer <token>
# → { "tunnels": [{ "subdomain", "port", "httpsUrl", "createdAt" }] }

DELETE /api/subdomains/mi-api
Authorization: Bearer <token>
# Libera un nombre reservado

Cómo funciona

dtunnel conecta tu localhost con una URL pública HTTPS bajo *.dtunnel.desarrollado.com. No necesitas abrir puertos en el router ni configurar DNS.

Arquitectura

flowchart TB
  subgraph INET["Internet"]
    U["Cliente HTTP / Webhook"]
  end

  subgraph VPS["VPS HestiaCP"]
    NG["Nginx :443"]
    WEB["Web estática + Admin"]
    API["API Node :3001\n+ gateway :18080"]
    NG --> WEB
    NG --> API
  end

  subgraph PC["Tu PC"]
    CLI["dtunnel CLI\n(Node.js)"]
    APP["127.0.0.1:PUERTO"]
    CLI --> API
    CLI <-->|WSS| API
    CLI --> APP
  end

  U -->|HTTPS| NG

Secuencia: abrir un túnel

sequenceDiagram
  participant Dev as Desarrollador
  participant CLI as dtunnel CLI
  participant API as API

  Dev->>CLI: dtunnel --port 88080
  CLI->>API: POST /api/tunnels
  API-->>CLI: subdomain, tunnelToken, wsUrl
  CLI->>API: WebSocket /tunnel/ws
  Note over CLI,API: Túnel activo mientras el CLI corre

Secuencia: visita HTTP

sequenceDiagram
  participant User as Visitante
  participant NG as Nginx
  participant API as API gateway
  participant CLI as dtunnel CLI
  participant App as localhost:88080

  User->>NG: GET https://mi-app.dtunnel.desarrollado.com
  NG->>API: proxy HTTP :18080
  API->>CLI: petición vía WebSocket
  CLI->>App: GET http://127.0.0.1:88080
  App-->>User: respuesta

Puertos en el VPS

Resumen en 5 pasos

1. El CLI pide un subdominio a la API y abre WebSocket con tunnelToken.
2. El cliente mantiene la conexión WSS hacia /tunnel/ws.
3. Un visitante abre https://nombre.dtunnel.desarrollado.com.
4. Nginx termina TLS y reenvía al gateway HTTP de la API (:18080).
5. La API reenvía la petición al CLI vía WebSocket → 127.0.0.1:PUERTO.

Límites y planes

«URL fija» significa que puedes reutilizar el mismo nombre cada vez que abres un túnel (tras reserve). No significa que la URL esté siempre en línea: hace falta tener el túnel activo con dtunnel --port.

Panel de administración

Superadmins pueden gestionar usuarios, planes, precios y límites en dtunnel-admin.desarrollado.com (requiere cuenta con permisos admin).

Desde el panel puedes:

• Ver estadísticas de usuarios y túneles activos
• Cambiar plan o desactivar cuentas
• Crear y editar planes (precio, límites de túneles y subdominios)
• Cerrar túneles activos en el servidor
• Ajustar el límite de túneles anónimos

Variables de entorno

También en ~/.dtunnel/config.json: localHost, apiUrl, token. Ver documentación y ejemplo Docker Compose.

El token de sesión y el tunnelToken los gestiona el CLI; no hace falta exportarlos manualmente.

Solución de problemas

Antivirus bloquea el túnel (modo legacy)

En v2 el modo por defecto es nativo (solo Node.js). Si usas --frp y el antivirus bloquea frpc, vuelve al modo nativo: dtunnel --port PUERTO sin --frp.

Node.js no encontrado (instalador curl)

El instalador v2 requiere Node.js 18+. Instálalo desde nodejs.org o con nvm, luego vuelve a ejecutar el script de instalación.

502 Bad Gateway en la URL pública

• Comprueba que dtunnel --port sigue en ejecución (no cerraste la terminal sin down).
• Verifica que tu app local responde: curl http://127.0.0.1:PUERTO (o curl http://mi-proyecto:PUERTO si usas --host)
• El puerto del CLI debe coincidir con el de tu app.

404 en el subdominio

• El túnel no está activo en tu máquina (dtunnel status debe mostrar conexión).
• Reservar un nombre no basta: necesitas dtunnel --port N -s nombre con el túnel en marcha.
• Con --subdomain, el nombre debe estar reservado en tu cuenta (dtunnel reserve o panel web).

WebSocket bloqueado en red corporativa

• Firewall o proxy que bloquea WSS saliente hacia dtunnel.desarrollado.com.
• Prueba desde otra red o usa modo legacy dtunnel --frp si está habilitado en el servidor.

Límite de túneles alcanzado

Ejecuta dtunnel down antes de abrir otro. Plan gratuito: 1 túnel; registrado: hasta 5.

La URL no carga desde otro dispositivo

• Usa la URL HTTPS que muestra el CLI.
• El túnel solo existe mientras tu PC ejecuta el CLI (no es hosting permanente en plan gratuito).

Más ayuda

Email: dtunnel@desarrollado.com · Obtener ayuda · GitHub · npm

Seguridad y SSL/TLS

dtunnel usa TLS en el borde (Nginx + Let's Encrypt) para que todas las URLs públicas sean https://. El tráfico entre visitante e Internet está cifrado hasta el VPS; dentro del servidor, Nginx reenvía en HTTP al gateway nativo de la API en localhost.

Mapa de cifrado y zonas de confianza

flowchart TB
  subgraph EXT["Zona pública — TLS activo"]
    V["Cliente HTTPS"]
    V -->|"TLS 1.2/1.3 :443"| NGX["Nginx"]
    CERT["Cert Let's Encrypt\n*.dtunnel.desarrollado.com"]
    CERT -.-> NGX
  end

  subgraph DMZ["VPS — no expuesto directamente"]
    NGX -->|"proxy_pass HTTP"| GW["API gateway :18080"]
    API["API :3001\nJWT + WSS /tunnel/ws"]
    NGX --> API
  end

  subgraph OUT["Conexión saliente autenticada"]
    GW <-->|"WSS + tunnelToken"| CLIENT["dtunnel CLI"]
  end

  subgraph LOOP["Loopback — tu máquina"]
    CLIENT --> APP["127.0.0.1:PUERTO"]
  end

  style EXT fill:#2b4278,color:#dce1ff
  style DMZ fill:#282a31,color:#e3e2e9
  style OUT fill:#424659,color:#dee0f9
  style LOOP fill:#1e4e4f,color:#bcebec

Handshake SSL (visitante)

sequenceDiagram
  participant B as Navegador
  participant NG as Nginx :443
  participant LE as Let's Encrypt
  participant GW as API gateway

  B->>NG: ClientHello (SNI: mi-app.dtunnel.desarrollado.com)
  NG->>B: ServerHello + certificado wildcard
  Note over B,NG: TLS establecido — tráfico cifrado
  B->>NG: GET / (HTTPS)
  NG->>GW: HTTP interno al túnel mi-app
  GW->>B: respuesta (cifrada en el camino de vuelta)

Autenticación del túnel (nativo v2)

sequenceDiagram
  participant CLI as dtunnel CLI
  participant API as API

  CLI->>API: POST /api/tunnels (opcional: Bearer JWT)
  API-->>CLI: subdomain + tunnelToken + wsUrl
  CLI->>API: WebSocket /tunnel/ws?token=...
  alt token inválido
    API-->>CLI: cierre 4001
  else token válido
    API-->>CLI: ready
  end

Buenas prácticas

• Comparte solo la URL HTTPS que muestra el CLI.
• No expongas paneles de admin sin login propio en la aplicación.
• Con cuenta registrada, solo tú puedes reservar y usar tus subdominios.
• Cierra el túnel con dtunnel down cuando termines de desarrollar.
• No commitees ~/.dtunnel/config.json ni frpc.toml (contienen tokens).