Integración de la API de HubSpot para Herramientas Internas Personalizadas: Guía con Node y Python (2026)

¿Sigues buscando una API key de HubSpot para montar tu integración con la API de HubSpot? Deja de buscar. HubSpot eliminó las API keys estáticas el 30 de noviembre de 2022, y el SDK actual de Node (@hubspot/api-client, ahora en la v14) tampoco las acepta. La credencial correcta para una herramienta interna de una sola cuenta es un token de acceso de app privada, y esta guía construye una sincronización real entre HubSpot y tu herramienta interna, tanto en Node como en Python, desde tu primera llamada create contact hasta un webhook validado por firma.

Respuesta rápida: Una integración con la API de HubSpot permite que una herramienta interna personalizada lea y escriba datos del CRM a través de la API REST v3 de HubSpot. Para una herramienta interna de una sola cuenta, autentícate con un token de acceso de app privada (HubSpot retiró las API keys en 2022) y sincroniza los cambios en tiempo real con webhooks en lugar de sondeo (polling).

Esto es lo que vas a construir:

• Autenticación con token de app privada y tu primera llamada create contact en Node y Python
• Un receptor de webhooks que valida X-HubSpot-Signature-v3 antes de confiar en un payload
• Una sincronización segura frente a errores 429, en lotes de 100, hacia un registro interno de tickets o ERP

¿Cómo Funciona la Integración con la API de HubSpot para Herramientas Internas Personalizadas?

Una integración con la API de HubSpot conecta una herramienta interna personalizada (una app de tickets, un ERP, un panel de facturación, un portal de clientes) con el CRM de HubSpot a través de su API REST v3. Tu herramienta lee y escribe objetos del CRM (contactos, negocios, empresas u objetos personalizados) mediante HTTPS con un token de acceso de app privada, y los cambios en tiempo real vuelven a través de webhooks.

Piensa en el CRM de HubSpot como una base de datos con la que hablas por HTTP. Cada registro es un objeto con un tipo y un ID. La solución hubspot crm api integration que estás construyendo hace dos trabajos: envía datos a HubSpot (crea un contacto cuando se abre un ticket) y extrae datos de él (lee un negocio cuando se renderiza tu panel interno).

La sincronización corre en una de dos direcciones. Una sincronización unidireccional copia los cambios de HubSpot a tu herramienta, o de tu herramienta a HubSpot. Una sincronización bidireccional hace ambas cosas y necesita protección contra bucles, algo que veremos más adelante. Y en lugar de preguntarle a HubSpot "¿hay algo nuevo?" cada minuto (sondeo o polling), registras un webhook para que HubSpot te avise en el instante en que un registro cambia.

Si prefieres ser dueño absoluto de tus datos en lugar de integrar un CRM alojado, autoalojar un CRM de código abierto es un camino distinto que vale la pena considerar antes de comprometerte. Pero si HubSpot ya es tu fuente de verdad, la API es cómo todo lo demás se comunica con él.

Para una herramienta interna de una sola cuenta, no necesitas OAuth ni una ficha en el marketplace de apps. Un token de app privada y un webhook son toda la integración.

Autenticación en 2026: Por Qué Ya No Existe la API Key de HubSpot

Para la autenticación con la API de HubSpot en una herramienta interna de una sola cuenta, usa un token de acceso de app privada. Es un token bearer estático que generas una sola vez en tu cuenta de HubSpot, con permisos limitados exactamente a los objetos que tu herramienta necesita tocar. No hay flujo de renovación ni caducidad. OAuth existe para apps públicas y multi-cuenta, no para el panel que tu equipo de operaciones ejecuta internamente.

Token de App Privada vs. la API Key Obsoleta

Aquí está la trampa que hace tropezar a la mitad de los desarrolladores que llegan a este resultado de búsqueda. HubSpot retiró las API keys el 30 de noviembre de 2022, y ahora están completamente sin soporte. El autocompletado todavía sugiere "hubspot api key" porque la memoria muscular no se ha puesto al día, pero no hay ninguna key que buscar. Recurre a una app privada de hubspot en su lugar: créala en Settings, otórgale los scopes que necesita y copia el token de acceso desde la pestaña Auth. La guía de apps privadas de HubSpot cubre la configuración.

Dos reglas sobre el token en sí. Otorga el mínimo privilegio necesario: si tu herramienta solo lee negocios y escribe contactos, solicita crm.objects.contacts.write y crm.objects.deals.read, nada más. Y guarda el token en una variable de entorno o en un gestor de secretos, envíalo en el encabezado Authorization: Bearer, y nunca lo hardcodees ni lo envíes al navegador.

El veredicto es sencillo. Para una herramienta interna, usa un token de acceso de app privada. Recurre a OAuth solo si esto más adelante se convierte en una app pública y multi-cuenta que otras empresas instalan en sus propios portales.

Tu Primera Llamada a la API de HubSpot: Crear un Contacto en Node y Python

La llamada inicial por excelencia es create contact, y los SDKs oficiales la reducen a unas pocas líneas. Instala el cliente, inicialízalo con tu token de app privada desde el entorno, luego crea un contacto y lee un negocio de vuelta. Es el mismo patrón que reutilizarás para empresas, tickets y llamadas a la hubspot custom objects api; solo cambia el tipo de objeto.

Aquí tienes la versión en Node con @hubspot/api-client (v14):

// npm i @hubspot/api-client   (v14.x)
import { Client } from "@hubspot/api-client";

// Token de app privada desde un gestor de secretos o variable de entorno, nunca hardcodeado
const hubspot = new Client({ accessToken: process.env.HUBSPOT_PRIVATE_APP_TOKEN });

// Crear un contacto
const { id } = await hubspot.crm.contacts.basicApi.create({
  properties: {
    email: "[email protected]",
    firstname: "Ada",
    lastname: "Lovelace",
    lifecyclestage: "lead",
  },
  associations: [],
});
console.log("Created contact", id);

// Leer un negocio por ID
const deal = await hubspot.crm.deals.basicApi.getById(
  "1234567890",
  ["dealname", "amount", "dealstage"],
);
console.log(deal.properties.dealname, deal.properties.amount);

Y lo mismo en Python con hubspot-api-client (v12):

# pip install hubspot-api-client   (v12.x)
import os
from hubspot import HubSpot
from hubspot.crm.contacts import SimplePublicObjectInputForCreate

# Token de app privada desde el entorno, no del control de versiones
client = HubSpot(access_token=os.environ["HUBSPOT_PRIVATE_APP_TOKEN"])

# Crear un contacto
contact = client.crm.contacts.basic_api.create(
    simple_public_object_input_for_create=SimplePublicObjectInputForCreate(
        properties={
            "email": "[email protected]",
            "firstname": "Ada",
            "lastname": "Lovelace",
            "lifecyclestage": "lead",
        }
    )
)
print("Created contact", contact.id)

# Leer un negocio por ID
deal = client.crm.deals.basic_api.get_by_id(
    deal_id="1234567890",
    properties=["dealname", "amount", "dealstage"],
)
print(deal.properties["dealname"], deal.properties["amount"])

Consejo profesional: prueba primero contra un sandbox de desarrollador de HubSpot, nunca en producción. Una llamada create mal formada en producción deja registros basura reales que tu equipo de ventas tendrá que limpiar. El token, los scopes y el modelo de objetos se comportan igual en el sandbox.

¿Cómo Sincronizas HubSpot con una Herramienta Interna en Tiempo Real?

Usa webhooks, no sondeo (polling). Registra una suscripción de webhook en tu app privada para el objeto y el evento que te interesa (por ejemplo, deal.propertyChange), apúntala a un endpoint HTTPS que tú alojes, y HubSpot te envía por POST un pequeño array JSON en el instante en que ocurre un cambio coincidente. Recurre al sondeo solo cuando no exista una suscripción para lo que necesitas vigilar.

La ganancia es eficiencia. El sondeo pregunta "¿hay algo nuevo?" cada minuto y consume tu límite de peticiones haciéndolo; un webhook simplemente te avisa en el instante en que un negocio cambia. Esa diferencia importa a escala, y los webhooks ya son algo habitual, no exótico: el informe State of the API 2025 de Postman, una encuesta a más de 5.700 desarrolladores, encontró que aproximadamente la mitad de los equipos los usan.

Registra la suscripción en la pestaña Webhooks de tu app privada, define la URL de destino y elige los eventos. HubSpot envía un array de objetos de evento, cada uno con el subscriptionType, el objectId y qué cambió. Aquí tienes un receptor básico en Node con Express:

import express from "express";

const app = express();
// Captura el cuerpo bruto (raw body): necesitas los bytes exactos para validar la firma después
app.use(express.json({
  verify: (req, _res, buf) => { req.rawBody = buf.toString("utf8"); },
}));

// HubSpot envía por POST un array de eventos a esta URL
app.post("/webhooks/hubspot", (req, res) => {
  const events = req.body; // [{ subscriptionType: "deal.propertyChange", objectId: 1234, ... }]
  for (const event of events) {
    console.log("HubSpot event:", event.subscriptionType, event.objectId);
    // Todavía NO confíes en este payload. La siguiente sección lo valida antes de actuar.
  }
  res.sendStatus(200);
});

app.listen(3000, () => console.log("Listening on :3000"));

Aquí es donde la construcción se vuelve real. Supongamos que estás sincronizando un negocio con el registro ERP de un pequeño fabricante: el webhook se dispara, tu handler crea o actualiza el ticket ERP correspondiente, y tu equipo de operaciones ve el cambio sin tocar HubSpot. Es el mismo enfoque en tiempo real que usamos para sincronizar un agente de voz con un CRM, solo que aquí el disparador es un cambio de propiedad en lugar de una llamada telefónica. Una advertencia: el receptor de arriba confía en cualquier cosa que le llegue por POST. Corrige eso antes de salir a producción.

Validar las Firmas de Webhooks (v3) para Nunca Confiar en un Payload Falsificado

Valida cada webhook entrante con la firma v3. HubSpot firma cada petición con el secreto de tu app y envía dos encabezados, X-HubSpot-Signature-v3 y X-HubSpot-Request-Timestamp. Rechaza todo lo que tenga más de 5 minutos, reconstruye la cadena de origen como método + URL completa + cuerpo bruto + timestamp, aplícale HMAC-SHA256 con el secreto de la app, codifícala en base64 y compárala en tiempo constante.

Si te saltas esto, cualquiera que adivine la URL de tu webhook puede falsificar una actualización de negocio. La validación no es opcional. La documentación de validación de peticiones de HubSpot y el changelog de firmas v3 detallan la receta exacta. Aquí tienes el middleware de Express, listo para usar:

import crypto from "crypto";

const CLIENT_SECRET = process.env.HUBSPOT_APP_SECRET; // desde la configuración de tu app privada
const MAX_AGE_MS = 5 * 60 * 1000; // rechaza todo lo que tenga más de 5 minutos

export function validateHubSpotSignature(req, res, next) {
  const signature = req.header("X-HubSpot-Signature-v3");
  const timestamp = req.header("X-HubSpot-Request-Timestamp");

  // 1. Rechaza peticiones caducadas (protección contra repetición)
  if (!signature || !timestamp || Date.now() - Number(timestamp) > MAX_AGE_MS) {
    return res.sendStatus(401);
  }

  // 2. Reconstruye la cadena de origen exacta: método + URL completa + cuerpo bruto + timestamp
  const uri = `https://${req.get("host")}${req.originalUrl}`;
  const source = `${req.method}${uri}${req.rawBody}${timestamp}`;

  // 3. HMAC-SHA256 con el secreto de la app, codificado en base64
  const hash = crypto
    .createHmac("sha256", CLIENT_SECRET)
    .update(source, "utf8")
    .digest("base64");

  // 4. Comparación en tiempo constante contra el encabezado
  const expected = Buffer.from(hash);
  const received = Buffer.from(signature);
  if (expected.length !== received.length ||
      !crypto.timingSafeEqual(expected, received)) {
    return res.sendStatus(401);
  }
  next();
}

La misma comprobación como función en Python, para que ambos stacks queden cubiertos:

import base64
import hashlib
import hmac
import os
import time

CLIENT_SECRET = os.environ["HUBSPOT_APP_SECRET"].encode("utf-8")
MAX_AGE_MS = 5 * 60 * 1000  # 5 minutos

def is_valid_signature(method, uri, body, signature, timestamp):
    # 1. Rechaza peticiones caducadas
    if not signature or not timestamp:
        return False
    if int(time.time() * 1000) - int(timestamp) > MAX_AGE_MS:
        return False

    # 2. método + URL completa + cuerpo bruto + timestamp
    source = f"{method}{uri}{body}{timestamp}".encode("utf-8")

    # 3. HMAC-SHA256, base64
    digest = hmac.new(CLIENT_SECRET, source, hashlib.sha256).digest()
    expected = base64.b64encode(digest).decode("utf-8")

    # 4. Comparación en tiempo constante
    return hmac.compare_digest(expected, signature)

La trampa que le cuesta una tarde entera a la gente: HubSpot firma la URL de destino completa, esquema, host y ruta juntos. Detrás de un proxy, un balanceador de carga o un túnel de ngrok, req.get("host") puede reportar el host interno en lugar del público que HubSpot firmó. Si la validación sigue fallando en un payload del que estás seguro que es legítimo, registra la URI exacta que reconstruiste y compárala con tu URL pública de webhook, carácter por carácter.

Límites de Peticiones, Errores 429 y la API de Lotes: Lo Que Corrimos en Producción

Las apps privadas obtienen aproximadamente 10 peticiones por segundo (100 cada 10 segundos en Free/Starter, 190 cada 10 segundos en Pro/Enterprise) con un límite diario de entre 250.000 y 1.000.000. La trampa: CRM Search tiene un límite aparte de 4 peticiones por segundo, y los endpoints de lotes aceptan un máximo de 100 registros por petición. Las pautas de uso de HubSpot detallan los niveles.

Aquí es donde la teoría se topó con un panel de staging en rojo. Durante una carga masiva esta primavera, enviamos alrededor de 8.000 registros existentes a HubSpot desde una herramienta interna de tickets y enriquecimos cada uno con una búsqueda de CRM Search. Estábamos usando @hubspot/api-client v14 en el lado de Node y hubspot-api-client v12 para un worker de enriquecimiento en Python. Las escrituras masivas fueron bien. Las llamadas de Search se cayeron en menos de un minuto, porque nuestro worker estaba disparando Search a unas 15 req/s contra un límite estricto de 4 req/s que no habíamos presupuestado por separado.

Dos cambios lo arreglaron. Primero, un wrapper de reintentos que lee los encabezados de respuesta X-HubSpot-RateLimit-* y aplica backoff ante un 429:

// Envuelve cualquier llamada a HubSpot; reintenta en 429 con backoff exponencial
async function withRetry(fn, maxRetries = 5) {
  let attempt = 0;
  while (true) {
    try {
      return await fn();
    } catch (err) {
      const status = err.code ?? err.response?.status;
      if (status !== 429 || attempt >= maxRetries) throw err;

      // Respeta la ventana de reinicio de HubSpot si el encabezado está presente
      const headers = err.response?.headers ?? {};
      const resetMs = Number(headers["x-hubspot-ratelimit-interval-milliseconds"]) || 0;
      const backoff = Math.max(resetMs, 2 ** attempt * 500); // 0.5s, 1s, 2s, 4s...

      console.warn(`429 hit, retry ${attempt + 1} in ${backoff}ms`);
      await new Promise((r) => setTimeout(r, backoff));
      attempt++;
    }
  }
}

Segundo, dejamos de escribir registros uno por uno. El endpoint de lotes admite hasta 100 registros por POST /crm/v3/objects/{objectType}/batch/create, así que dividimos la carga masiva en 80 llamadas por lotes en lugar de 8.000 POSTs individuales:

// Los endpoints de lotes de HubSpot aceptan como máximo 100 registros por petición
function chunk(arr, size = 100) {
  const out = [];
  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
  return out;
}

// POST /crm/v3/objects/contacts/batch/create, dividido en lotes de 100
async function batchCreateContacts(records) {
  for (const group of chunk(records, 100)) {
    const inputs = group.map((r) => ({
      properties: { email: r.email, firstname: r.firstName, lastname: r.lastName },
      associations: [],
    }));
    await withRetry(() => hubspot.crm.contacts.batchApi.create({ inputs }));
    console.log(`Wrote ${group.length} contacts`);
  }
}

Limitar el worker de Search a 4 req/s y agrupar las escrituras en lotes convirtió una ejecución ahogada en reintentos en una que terminó sin sobresaltos. Si te quedas con un solo número de esta sección, que sea el 4: el límite de CRM Search es el que muerde en producción, y es el que todos los artículos recopilatorios se olvidan de mencionar. El antiguo límite de "10 para contactos" en los lotes, por cierto, ya no existe; el actual es 100 en todos los tipos de objeto.

Sincronización Bidireccional: Escribir Cambios de Vuelta a HubSpot Sin Bucles Infinitos

Una sincronización bidireccional escribe cambios de vuelta a HubSpot desde tu herramienta interna, además de leerlos. El peligro es un bucle de retroalimentación: tu escritura de vuelta dispara el mismo webhook que activó tu handler, que vuelve a escribir, para siempre. Evítalo con una clave de idempotencia (omite cambios que ya aplicaste) y una marca de origen (ignora los eventos entrantes que tu propia herramienta provocó).

const processed = new Set(); // usa Redis o una restricción única de BD en producción

async function writeBackToHubSpot(record) {
  // Clave de deduplicación: id del objeto + un hash del cambio que estamos por aplicar
  const key = `${record.id}:${record.updatedHash}`;
  if (processed.has(key)) return; // este cambio exacto ya se sincronizó
  processed.add(key);

  await withRetry(() =>
    hubspot.crm.contacts.basicApi.update(record.id, {
      // Marca el origen para que el webhook resultante sea ignorado por nuestro propio receptor
      // (verifica source: "internal-tool" antes de actuar sobre un evento entrante)
      properties: { internal_status: record.status, last_sync_source: "internal-tool" },
    })
  );
}

El patrón es pequeño, pero saltárselo es cómo una sincronización duplica en silencio tu volumen de escritura de la noche a la mañana. Una vez que los datos están limpios en ambas direcciones, los equipos suelen alimentar con ellos un pipeline de AI SDR o una capa de reporting. El tutorial de integración con HubSpot de Nango es una referencia sólida solo para Node si quieres otra perspectiva sobre la sincronización bidireccional, aunque tendrás que portar tú mismo la idea de prevención de bucles.

¿Deberías Construir Esto Internamente o Contratar a un Partner de Integración?

Constrúyelo internamente cuando la sincronización es pequeña, estable y tiene dueño: un flujo unidireccional, un puñado de objetos, y un ingeniero que pueda absorber los cambios disruptivos de HubSpot, que llegan más o menos dos veces al año. Contrata a un partner cuando necesites sincronización bidireccional, modelado de objetos personalizados, o cuando nadie en el equipo pueda hacerse cargo del mantenimiento continuo. El factor decisivo casi nunca es la construcción inicial; es quién la vigila dentro de un año.

Aquí tienes una checklist honesta. Constrúyelo tú mismo si: la dirección es unidireccional, estás sincronizando objetos estándar, tienes un desarrollador que puede alojar un endpoint de webhook, y alguien notará cuando un payload empiece a fallar. Todo lo anterior es tu plano de construcción.

Contrata a un partner si: necesitas sincronización bidireccional con prevención de bucles entre varios objetos, estás modelando objetos personalizados con asociaciones tipadas, estás conectando varios sistemas (HubSpot más un ERP más facturación), o la persona que lo mantendría ya está al límite de su capacidad. HubSpot usa un versionado de API basado en fechas con cambios disruptivos solo unas dos veces al año, lo cual suena tranquilo hasta que uno cae justo en tu semana más ocupada y no hay nadie a cargo. Esa cola de mantenimiento, no el primer despliegue, es lo que hunde en silencio las integraciones internas. Si prefieres no encargarte tú mismo, ahí es donde entran nuestros servicios de integración de CRM a medida.

Puntos Clave

• No existe la API key de HubSpot. Usa un token de acceso de app privada para una herramienta interna de una sola cuenta; OAuth es solo para apps públicas y multi-cuenta.
• Valida siempre X-HubSpot-Signature-v3 antes de confiar en un payload de webhook. Reconstruye la cadena de origen con la URL de destino completa.
• Respeta el límite de 4 req/s de CRM Search y agrupa las escrituras grandes en lotes de 100 con backoff ante errores 429.
• Prefiere los webhooks al sondeo para la sincronización en tiempo real, y una integración con HubSpot es solo una pieza de un stack más amplio de herramientas de IA para empresas.

¿Atascado con el mantenimiento, o quieres una segunda opinión antes de lanzar? Reserva una consultoría de integración gratuita. Sin presión de ningún lado; el código de arriba es tuyo para usarlo de todas formas.

Preguntas Frecuentes

¿Todavía necesito una API key de HubSpot en 2026?

No. HubSpot retiró las API keys estáticas el 30 de noviembre de 2022, y están completamente sin soporte. El autocompletado todavía sugiere "hubspot api key" por costumbre, pero no hay nada que buscar. Para una herramienta interna de una sola cuenta, crea una app privada en Settings y usa su token de acceso en su lugar.

¿Cuál es la diferencia entre un token de app privada y OAuth en HubSpot?

Un token de acceso de app privada es una credencial estática para una sola cuenta de HubSpot, sin caducidad y sin flujo de renovación, ideal para una herramienta interna. OAuth 2.0 es para apps públicas y multi-cuenta que otras empresas instalan en sus propios portales; sus tokens caducan en unas seis horas y requieren un ciclo de renovación.

¿Cuáles son los límites de peticiones de la API de HubSpot en 2026?

Las apps privadas obtienen unas 10 peticiones por segundo (100 cada 10 segundos en Free/Starter, 190 en Pro/Enterprise) con un límite diario de 250.000 a 1.000.000. La API de CRM Search tiene un límite aparte de 4 peticiones por segundo, y los endpoints de lotes aceptan un máximo de 100 registros por petición.

¿Cómo valido la firma de un webhook de HubSpot?

Usa la receta v3: rechaza las peticiones donde X-HubSpot-Request-Timestamp tenga más de cinco minutos, luego construye una cadena de origen con método más URL de destino completa más cuerpo bruto más timestamp. Aplícale HMAC-SHA256 con el secreto de tu app, codifica el resultado en base64 y compáralo con X-HubSpot-Signature-v3 en tiempo constante.

¿Qué SDK de HubSpot debería usar, Node o Python?

Ambos son oficiales y están mantenidos. Node usa @hubspot/api-client (v14) y Python usa hubspot-api-client (v12). Ambos exponen el mismo modelo de objetos del CRM v3, así que elige el que mejor encaje con tu stack. Esta guía incluye código idéntico de autenticación y validación de firma en los dos lenguajes.

¿Cómo sincronizo HubSpot con una herramienta interna personalizada en tiempo real?

Registra una suscripción de webhook en tu app privada para el objeto y el evento que te interesa, y luego aloja un endpoint HTTPS al que HubSpot envíe un POST cuando ocurra un cambio coincidente. Valida la firma y después escribe el cambio en tu herramienta interna. Recurre al sondeo solo cuando ninguna suscripción de webhook cubra lo que necesitas.

¿Qué es una Service Key de HubSpot y debería usarla?

Una Service Key es una credencial de solo datos a nivel de cuenta que HubSpot lanzó en beta pública en febrero de 2026. Está pensada para tareas del lado del servidor que solo tocan datos. Para una herramienta interna estándar hoy en día, un token de acceso de app privada sigue siendo la opción por defecto más segura y mejor documentada; trata las Service Keys como beta hasta que se gradúen.

¿Puedo probar una integración de HubSpot sin tocar producción?

Sí. Crea un sandbox de desarrollador de HubSpot y apunta tu token de app privada hacia él. Los scopes, el modelo de objetos, los webhooks y los límites de peticiones se comportan igual que en producción, así que puedes crear contactos de prueba y disparar webhooks sin dejar registros basura que tu equipo de ventas tenga que limpiar después.

¿Cuántos registros puede recibir la API de lotes de HubSpot a la vez?

Los endpoints de lotes (POST /crm/v3/objects/{objectType}/batch/create y sus equivalentes de update y upsert) aceptan un máximo de 100 registros por petición. Divide los payloads más grandes en grupos de 100. El antiguo límite de "10 registros para contactos" que algunos tutoriales todavía citan ya ha sido eliminado; el actual es 100 en todos los tipos de objeto.

¿Debería construir esto internamente o contratar a una agencia?

Constrúyelo internamente cuando la sincronización es unidireccional, usa objetos estándar y tiene un dueño que puede absorber los cambios disruptivos de HubSpot, que llegan dos veces al año. Contrata a un partner para sincronización bidireccional, modelado de objetos personalizados, o cuando nadie pueda hacerse cargo del mantenimiento. El primer despliegue es fácil; el año de mantenimiento posterior es el costo real.