Plan de Negocio para Granja de Minería 50 kW: CAPEX y ROI

Montar una granja de minería de 50 kW es ese escenario fronterizo entre un enchufe residencial pesado y un centro de datos comercial. Por un lado, una carga activa de 50 kW todavía se puede meter en un local comercial pequeño o en una propiedad privada con su propio transformador. Por el otro, estamos hablando de unos 14 a 15 mineros ASIC modernos, donde cada máquina bota hasta 3.5 kW de calor, jala de 15 a 16 amperios por fase y exige un caudal de aire de 600 a 800 metros cúbicos por hora.

Esta guía trae el desglose técnico directo al grano sobre diseño, compra de hardware, cableado eléctrico, refrigeración y automatización para una granja de minería de 50 kW. Sin rodeos, teoría abstracta o academicismo: puros números duros, fierros, cables, perfiles de nivel freático y scripts de monitoreo listos para producción.

1. Parámetros iniciales e infraestructura eléctrica

La base de cualquier negocio de minería es el costo del kilovatio-hora y la confiabilidad de la subestación. Para una carga continua de 50 kW operando 24/7, la protección general de entrada debe dimensionarse con un margen de seguridad del 20% en corriente (según las normas NFPA/IEC para cargas continuas).

I_total = P / (√3 · U · cosφ) = 50000 / (√3 · 380 · 0.95) ≈ 79.8 A

Tomando en cuenta el factor de 1.25, el interruptor general de entrada debe calcularse para un mínimo de 100 A (trifásico).

Especificación del tablero eléctrico general (Tablero Principal 50 kW)

• Interruptor principal: 3P 100 A (curva C, capacidad de interrupción de al menos 10 kA, por ejemplo, Schneider Electric Acti9 o ABB S200).
• Balanceo de fases: 3 fases L1, L2, L3, distribuidas de forma estrictamente equitativa con 5 equipos por fase (para un total de 15 dispositivos) para evitar desequilibrios de fases y corrientes excesivas en el neutro.
• Línea de cableado desde el transformador al tablero principal: Cable de cobre RV-K 4x25 mm² o aluminio 4x50 mm² en tendido subterráneo (considerando una caída de tensión máxima del 2% en 50 metros).
• Protección de circuitos derivados: Para cada ASIC, un interruptor dedicado 2P 20 A (curva C) + cable de cobre libre de halógenos con doble aislamiento 3x2.5 mm².
• Sistema de puesta a tierra: Malla o pozo de tierra tipo TN-S o TN-C-S con una resistencia menor a 4 ohms (armado con 3 barras cobreadas de 2.5 m hincadas en triángulo y soldadas con pletina de cobre de 40x4 mm).

2. Selección de hardware y CAPEX (Gastos de capital)

Para los cálculos tomaremos el estándar de oro de la industria: las series Bitmain Antminer S19k Pro / S21 o MicroBT Whatsminer M50/M60. Para clavar una carga exacta de 50 kW, lo óptimo es meter 14 unidades del Antminer S21 (200 TH/s) con un consumo estándar de unos 3,500 W por equipo.

• Hashrate total: 14 · 200 TH/s = 2,800 TH/s = 2.8 PH/s
• Consumo total: 14 · 3,500 W = 49 kW (entra perfecto dentro del límite de 50 kW dejando margen para la ventilación).

Tabla de gastos de capital (CAPEX)

3. Refrigeración y ventilación: Cálculo termodinámico

El error clásico del novato: meter un aire acondicionado residencial. El aire acondicionado remueve humedad y baja la temperatura mediante un ciclo de refrigeración por gas, pero para 50 kW de carga térmica necesitarías un monstruo de 150,000 BTU que se tragaría otros 15 a 18 kW de electricidad por su cuenta.

La minería se enfría exclusivamente con ventilación mecánica de flujo continuo (inyección y extracción forzada de aire).

Cálculo del caudal de aire necesario

Fórmula del flujo de aire requerido:

Q = P_dissip / (ρ · c_p · ΔT)

Donde:

• P_dissip = 49,000 W (calor disipado)
• ρ = 1.2 kg/m³ (densidad del aire a 20 °C)
• c_p = 1,005 J/(kg·K) (capacidad térmica másica del aire)
• ΔT = 15 °C (incremento de temperatura permisible entre la entrada y la salida)

Q = 49000 / (1.2 · 1005 · 15) ≈ 2.708 m³/s = 9,750 m³/h

Tomando en cuenta la caída de presión de los filtros gruesos (G4), debes dimensionar ventiladores con una capacidad total de al menos 12,000 a 14,000 m³/h.

Segmentación de zonas (Pasillo caliente / Pasillo frío)

• Pasillo frío: Inyección de aire exterior a través de una pared filtrante. Aquí la presión estática se mantiene ligeramente positiva.
• Pasillo caliente: Los mineros ASIC van montados en una mampara sellada (rack con ductos direccionales). Los abanicos de los propios aparatos expulsan el aire caliente directo a una cámara aislada, desde donde un extractor industrial lo bota hacia la calle.

4. OPEX y gastos operativos (Cálculo mensual)

Los gastos de operación se componen de tres elementos clave: electricidad, renta del local, internet y mantenimiento preventivo.

Usaremos un costo promedio de electricidad comercial de $0.07 por kWh.

Cálculo de la factura eléctrica mensual

• Consumo por hora: 49 kW (mineros) + 1.5 kW (ventilación y red) = 50.5 kW
• Consumo diario: 50.5 · 24 = 1,212 kWh
• Consumo mensual (30.5 días): 1,212 · 30.5 = 36,966 kWh
• Gasto de luz al mes: 36,966 · $0.07 = $2,587.62

Gastos fijos mensuales (OPEX)

5. Proyección de ingresos, ROI (Retorno de inversión) y modelo financiero

Para proyectar los ingresos se aplican las métricas de dificultad de la red de Bitcoin y la recompensa por bloque vigentes para 2026. Asumamos que 1 TH/s genera aproximadamente $0.042 al día (sin descontar la luz, con un precio de BTC de ~$65,000).

Cálculo de ingresos (Revenue)

• Hashrate total: 2,800 TH/s
• Ingreso diario: 2,800 · $0.042 = $117.60
• Ingreso mensual (30.5 días): $117.60 · 30.5 = $3,586.80

Utilidad neta (EBITDA / Net Profit)

• Net Profit/mo = Ingresos ($3,586.80) - OPEX ($3,077.62) = $509.18 (si la rentabilidad por TH/s sube, la cifra mejora; con BTC a $90,000 la ganancia escala de forma proporcional).

Nota importante sobre la sensibilidad del ROI ante el precio y la tarifa eléctrica:
Si el costo de la luz baja a $0.05 / kWh, el OPEX eléctrico cae a $1,848.30 y la utilidad neta sube a $1,248.50 mensuales. Esto reduce el plazo de recuperación de una cifra catastrófica a unos razonables 35 a 40 meses. Minerar con tarifa comercial por encima de $0.065–0.07/kWh sin un bull run o hardware súper eficiente te coloca directo en la zona de alto riesgo.

6. Automatización y control: Script de Python para monitoreo (CGMiner / CGMiner API)

Ningún ingeniero de verdad se pone a revisar manualmente las interfaces web de 14 equipos uno por uno. Todos los mineros ASIC modernos (Antminer, Whatsminer) soportan el protocolo CGMiner API (basado en JSON a través de sockets TCP).

Abajo tienes un script de Python listo para producción para monitorear el pool de tu granja. El script consulta los 14 ASIC en la red local, recopila el hashrate y la temperatura de los chips, y manda una alerta directa a Telegram si hay una caída de rendimiento o un recalentamiento.

#!/usr/bin/env python3
"""
Monitoreo de granja de mineros ASIC mediante CGMiner API (Puerto 4028).
Características:
  * consulta todos los dispositivos en paralelo;
  * Antminer (clave "command") y Whatsminer (clave "cmd") — el tipo se define en MINERS;
  * alertas: sin conexión, caída de hashrate, recalentamiento, campos de temperatura no encontrados;
  * desduplicación: el mismo evento no se envía con más frecuencia que REPEAT_MINUTES;
  * aviso de recuperación cuando el problema desaparece;
  * confirmación del problema durante CONFIRM_CYCLES consultas consecutivas (protección contra falsos positivos);
  * el estado se guarda en un archivo, por lo que funciona perfectamente tanto en bucle como desde cron (--once).
Configuración mediante variables de entorno:
  TG_BOT_TOKEN, TG_CHAT_ID              — obligatorias
  TEMP_THRESHOLD (por defecto 85)       — umbral de temperatura de los chips, °C
  HASHRATE_WARN_TH (por defecto 170)    — hashrate mínimo aceptable, TH/s
  POLL_INTERVAL_SEC (por defecto 60)    — periodo de consulta en modo bucle
  REPEAT_MINUTES (por defecto 60)       — repetición de la misma alerta
  CONFIRM_CYCLES (por defecto 2)        — cuántas consultas consecutivas debe persistir el problema
Ejecución:
  python3 asic_monitor.py               # bucle infinito
  python3 asic_monitor.py --once        # una sola ejecución (para cron / systemd timer)
IMPORTANTE: El puerto 4028 solo debe ser accesible desde la red local.
Nunca lo expongas hacia afuera.
"""
import json
import logging
import os
import socket
import sys
import time
from concurrent.futures import ThreadPoolExecutor
import requests
# --------------------------------------------------------------------------
# Configuración
# --------------------------------------------------------------------------
# (ip, tipo): "antminer" o "whatsminer"
MINERS = [(f"192.168.1.{i}", "antminer") for i in range(101, 115)]  # .101 - .114
# Ejemplo de granja mixta:
# MINERS[0] = ("192.168.1.101", "whatsminer")
API_PORT = 4028
SOCKET_TIMEOUT = 3.0
TG_BOT_TOKEN = os.environ.get("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.environ.get("TG_CHAT_ID", "")
TEMP_THRESHOLD = float(os.environ.get("TEMP_THRESHOLD", "85"))
HASHRATE_WARN_TH = float(os.environ.get("HASHRATE_WARN_TH", "170"))
POLL_INTERVAL_SEC = int(os.environ.get("POLL_INTERVAL_SEC", "60"))
REPEAT_MINUTES = int(os.environ.get("REPEAT_MINUTES", "60"))
CONFIRM_CYCLES = int(os.environ.get("CONFIRM_CYCLES", "2"))
STATE_FILE = os.environ.get("STATE_FILE", "asic_monitor_state.json")
# Prefijos de las claves de temperatura de los chips en la respuesta `stats` de Antminer.
# Verifícalo con tu firmware: ejecuta `stats` y revisa las claves reales.
ANTMINER_TEMP_PREFIXES = ("temp2_", "temp_chip")
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("asic_monitor")
# --------------------------------------------------------------------------
# Telegram
# --------------------------------------------------------------------------
def send_telegram(text: str) -> bool:
    """Envía un mensaje sin parse_mode (el texto dinámico no rompe el formato).
    Devuelve True solo si Telegram acepta el mensaje."""
    if not TG_BOT_TOKEN or not TG_CHAT_ID:
        log.error("TG_BOT_TOKEN / TG_CHAT_ID no configurados, alerta no enviada: %s", text)
        return False
    url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
    try:
        r = requests.post(url, json={"chat_id": TG_CHAT_ID, "text": text}, timeout=10)
        if not r.ok:
            log.error("Telegram devolvió %s: %s", r.status_code, r.text[:200])
        return r.ok
    except requests.RequestException as e:
        log.error("Error al enviar a Telegram: %s", e)
        return False
# --------------------------------------------------------------------------
# Interacción con la API de CGMiner
# --------------------------------------------------------------------------
def query_miner(ip: str, kind: str, command: str) -> dict:
    """Envía un comando a la API de CGMiner. Si hay error, devuelve {"error": "..."}."""
    key = "cmd" if kind == "whatsminer" else "command"
    try:
        with socket.create_connection((ip, API_PORT), timeout=SOCKET_TIMEOUT) as s:
            s.settimeout(SOCKET_TIMEOUT)
            s.sendall(json.dumps({key: command}).encode("utf-8"))
            chunks = []
            while True:
                chunk = s.recv(4096)
                if not chunk:
                    break
                chunks.append(chunk)
        text = b"".join(chunks).decode("utf-8", errors="ignore").replace("\x00", "")
        # Algunos firmwares devuelven "}{" sin coma entre los objetos
        text = text.replace("}{", "},{")
        return json.loads(text)
    except Exception as e:  # red, timeout, JSON inválido
        return {"error": f"{type(e).__name__}: {e}"}
def to_float(value):
    """Número o cadena numérica -> float, de lo contrario None."""
    try:
        return float(value)
    except (TypeError, ValueError):
        return None
def get_hashrate_th(summary: dict, kind: str):
    """Hashrate en TH/s o None si no se encuentra el campo."""
    try:
        s = summary["SUMMARY"][0]
    except (KeyError, IndexError, TypeError):
        return None
    if kind == "whatsminer":
        # MH/s -> TH/s. Promedio de 5 minutos si está disponible, si no, el promedio de toda la sesión.
        for key in ("MHS 5m", "MHS av"):
            v = to_float(s.get(key))
            if v is not None:
                return v / 1_000_000.0
        return None
    # Antminer: GH/s -> TH/s. Evitamos "GHS 5s" (demasiado inestable).
    for key in ("rate_30m", "GHS av"):
        v = to_float(s.get(key))
        if v is not None:
            return v / 1000.0
    return None
def get_max_chip_temp(ip: str, kind: str, summary: dict):
    """Temperatura máxima de los chips o None si no se encuentran los campos."""
    if kind == "whatsminer":
        try:
            s = summary["SUMMARY"][0]
        except (KeyError, IndexError, TypeError):
            return None
        temps = [to_float(s.get(k)) for k in ("Chip Temp Max", "Temperature")]
        temps = [t for t in temps if t]
        return max(temps) if temps else None
    stats = query_miner(ip, kind, "stats")
    try:
        info = stats["STATS"][1]
    except (KeyError, IndexError, TypeError):
        return None
    temps = []
    for k, v in info.items():
        if k.startswith(ANTMINER_TEMP_PREFIXES):
            t = to_float(v)
            if t:  # 0 = la placa no está devolviendo valor
                temps.append(t)
    return max(temps) if temps else None
# --------------------------------------------------------------------------
# Verificación de un solo dispositivo
# --------------------------------------------------------------------------
def check_miner(ip: str, kind: str) -> dict:
    """Devuelve {issue_key: texto_alerta} para los problemas activos."""
    issues = {}
    summary = query_miner(ip, kind, "summary")
    if "error" in summary:
        # Sin conexión: las demás verificaciones no tienen sentido
        return {"offline": f"⚠️ {ip}: sin respuesta de la API ({summary['error']})"}
    th = get_hashrate_th(summary, kind)
    if th is None:
        issues["parse"] = f"❌ {ip}: no se pudo obtener el hashrate del summary (revisa el firmware/tipo)"
    elif th < HASHRATE_WARN_TH:
        issues["hashrate"] = f"📉 {ip}: hashrate de {th:.1f} TH/s (umbral {HASHRATE_WARN_TH:.0f})"
    temp = get_max_chip_temp(ip, kind, summary)
    if temp is None:
        issues["temp_keys"] = f"❓ {ip}: no se encontraron campos de temperatura, revisa las claves en stats"
    elif temp > TEMP_THRESHOLD:
        issues["temp"] = f"🔥 {ip}: recalentamiento, chips a {temp:.0f}°C (umbral {TEMP_THRESHOLD:.0f})"
    return issues
# --------------------------------------------------------------------------
# Estado y desduplicación
# --------------------------------------------------------------------------
def load_state() -> dict:
    try:
        with open(STATE_FILE, encoding="utf-8") as f:
            return json.load(f)
    except (OSError, ValueError):
        return {"sent": {}, "streak": {}}
def save_state(state: dict) -> None:
    try:
        tmp = STATE_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            json.dump(state, f)
        os.replace(tmp, STATE_FILE)
    except OSError as e:
        log.error("No se pudo guardar el estado: %s", e)
def run_cycle(state: dict) -> None:
    sent, streak = state["sent"], state["streak"]
    now = time.time()
    with ThreadPoolExecutor(max_workers=len(MINERS)) as pool:
        results = list(pool.map(lambda m: (m[0], check_miner(*m)), MINERS))
    for ip, issues in results:
        # 1) problemas activos
        for key, text in issues.items():
            sid = f"{ip}|{key}"
            streak[sid] = streak.get(sid, 0) + 1
            if streak[sid] < CONFIRM_CYCLES:
                continue
            last = sent.get(sid)
            if last is None or now - last >= REPEAT_MINUTES * 60:
                if send_telegram(text):
                    sent[sid] = now
        # 2) problemas resueltos
        prefix = f"{ip}|"
        for sid in [s for s in list(streak) if s.startswith(prefix)]:
            key = sid[len(prefix):]
            if key in issues:
                continue
            streak.pop(sid, None)
            if sid in sent:  # notificamos la recuperación solo si se había enviado una alerta antes
                if send_telegram(f"✅ {ip}: problema «{key}» solucionado"):
                    sent.pop(sid, None)
    ok = sum(1 for _, i in results if not i)
    log.info("Monitoreo completado: %d/%d sin problemas", ok, len(results))
    save_state(state)
# --------------------------------------------------------------------------
def main() -> None:
    state = load_state()
    state.setdefault("sent", {})
    state.setdefault("streak", {})
    if "--once" in sys.argv:
        run_cycle(state)
        return
    log.info("Iniciando monitoreo: %d dispositivos, periodo de %d s", len(MINERS), POLL_INTERVAL_SEC)
    while True:
        try:
            run_cycle(state)
        except Exception:
            log.exception("Excepción no controlada en el ciclo de sondeo")
        time.sleep(POLL_INTERVAL_SEC)
if __name__ == "__main__":
    main()

7. Checklist previo al arranque (Aprobación de ingeniería)

• 1. Prueba de carga eléctrica: Pon a funcionar un cañón calefactor de 50 kW durante 4 horas antes de instalar los mineros. Comprueba con un pirómetro el calentamiento de los bloques de contactos en el interruptor principal y en las barras colectoras. La temperatura de los contactos no debe superar los 65°C.
• 2. Medición de puesta a tierra: Llama a un laboratorio eléctrico para medir la impedancia del bucle de falla fase-neutro y la resistencia de dispersión del sistema de puesta a tierra (debe ser < 4 ohms).
• 3. Verificación de flujo de aire: Asegúrate de que la caída de presión del filtro G4 no genere un vacío en la estancia (la puerta hacia el pasillo frío debe abrirse sin un esfuerzo excesivo mientras los extractores están funcionando).
• 4. Configuración del Watchdog: Habilita las funciones integradas de reinicio automático por hardware (Hardware Auto-Reboot) en el firmware de los mineros (LUXOS, VNISH o Stock) por si se cae el pool o se pierde la IP.

Ejecución:

export TG_BOT_TOKEN="..." TG_CHAT_ID="..."
python3 asic_monitor.py

8. Marco legal, contrato PPA y contabilidad fiscal internacional

Montar un chiringuito de 50 kW en cualquier jurisdicción exige el estatus oficial de consumidor comercial. Minar "por debajo de la mesa" colgándose de un enchufe residencial común te va a traer tarde o temprano una cartita de la compañía eléctrica, multas picantes por pasarle por encima a los límites de potencia y cargos por uso irregular de la red.

Esquema de estructuración y arquitectura legal

• Constitución de la empresa operadora (LLC / S.A.S. / Inc.): La infraestructura se registra bajo una entidad jurídica estándar de responsabilidad limitada. Esto es obligatorio para firmar legalmente contratos de alquiler comercial y acuerdos de interconexión con la red eléctrica.
• Contrato PPA (Power Purchase Agreement): El documento clave de la granja es el contrato comercial de suministro eléctrico (PPA) firmado con la comercializadora o el dueño de la subestación. El contrato amarra lo siguiente:
  • Potencia activa asignada: 50 kW bajo la categoría de confiabilidad III (con carga continua permitida 24/7).
  • Punto de entrega y frontera: 0.4 kV en las barras de baja tensión del transformador.
  • Esquema tarifario: Costo fijo por kWh (target < $0.065–0.07).
• Importación de hardware (Código HS 8471): La compra de los ASIC miners se hace mediante contrato B2B directo. El código del Sistema Armonizado (HS Code) internacional para el equipo es el 8471 50 000 0 (unidades de procesamiento). Con un despacho de aduanas en regla se pagan los impuestos a la importación (VAT/GST) y aranceles, quedando en mano las declaraciones de importación y facturas comerciales que respaldan el origen de los activos fijos.
• Contabilidad fiscal y off-ramping: Las ganancias del minado se generan en BTC directamente en el pool. Para cubrir los gastos operativos mensuales (OPEX: luz, alquiler), se utiliza una cuenta institucional (Corporate Account) en un exchange de criptomonedas o mesa OTC que ya tenga el proceso de KYB (Know Your Business) aprobado. Los fondos en fiat obtenidos se transfieren a la cuenta bancaria corporativa por transferencia bancaria para pagar los recibos de luz al día.

9. Logística y recepción de equipos

El peso total de 14 unidades Antminer S21 en su empaque de fábrica ronda entre los 230 y 250 kg.

Protocolo de inspección de entrada (QC al recibir)

• 1. Inspección visual del embalaje: Revisar los sellos de seguridad (tamper-evident) y que las cajas no vengan golpeadas.
• 2. Shake test (Prueba de los disipadores): Con el transporte internacional, las vibraciones fuertes pueden aflojar los tornillos de sujeción o hacer que se despeguen los disipadores individuales de los chips (sobre todo en equipos usados). Se sacude el equipo suavemente: no debe escucharse ningún ruidito de piezas sueltas por dentro.
• 3. Prueba de resistencia (Cold test): Antes de meterle 220V, se le pasa un multímetro para checar que no haya cortos en los buses de alimentación de las hashboards (la resistencia de la línea VDD debe dar dentro del rango del fabricante, de unas cuantas decenas de ohms).
• 4. Banco de pruebas (15 minutos): Encendido secuencial en un circuito aislado. Validar que pegue el hashrate objetivo (200 TH/s), que respondan las 3 placas (3/3 Boards detected) y que traiga tasa baja de errores de hardware (HW Errors < 0.5%).

10. Seguridad y aislamiento de red

Una granja de 50 kW es un caramelo tanto para robo físico como para ataques de red (secuestro de tráfico stratum, inyección de malware de minería).

Arquitectura de la topología de red:
[ Internet (WAN) ]
          &│
     [ Respaldo 4G/LTE ]
           &│
   ┌───────┴────────┐
   │ Router / WAF │ (MikroTik / OPNsense)
   │ Firewall │ ── WireGuard VPN (Solo acceso remoto)
   └───────┬────────┘
           │ (VLAN aislada 10.0.10.0/24)
  ┌────────┼─────────────────┬─────────────────┐
  │        │                 │                 │
[ASIC 1] [ASIC 2] ...    [ASIC 14]     [Node del script]
10.0.10.101 10.0.10.102  10.0.10.114    10.0.10.250 (Python Watchdog)

Parámetros del perímetro de red

• Aislamiento total de la WAN: Los ASIC se quedan encerrados en un segmento de VLAN sin IP pública expuesta.
• Puerto 4028 cerrado (CGMiner API): El acceso al puerto de métricas está abierto estrictamente para la IP del servidor de monitoreo interno.
• Cifrado Stratum/TLS: Enrutar el tráfico al pool mediante Stratum V2 o Stratum over TLS elimina cualquier riesgo de ataques de tipo Man-in-the-Middle (MitM) para desviar la wallet a nivel del proveedor de Internet.

11. Resumen del ingeniero (Checklist de despliegue)

• 1. Eléctrica: Checar el calibre de los cables VVGng-LS 3x2.5 mm² para cada toma C19, repasar con torquímetro todas las terminales en el tablero general (MDP) después de 48 horas de operación a carga completa.
• 2. Ventilación: Medir el delta de temperatura entre la entrada de aire y la extracción. Si $\Delta T > 18^\circ\text{C}$, subirle las revoluciones a los extractores mediante variador de frecuencia (VFD).
• 3. Monitoreo: Levantar el script automatizado de control de los ASIC con alertas activas si el hashrate se cae por debajo de los 170 TH/s.
• 4. Gestión de riesgo financiero: Calcular el punto de equilibrio (break-even) contemplando que la dificultad de la red puede crecer un 15–20% anual.