Variables y contexto - Insurance Boosters API

Antes de ejecutar un paso, la API resuelve las plantillas {{...}} dentro de su input. El paso browser.use también las resuelve dentro de task. Así pasas datos del disparo y entre pasos sin hardcodearlos.

Tres formas de pasar datos entre pasos

Forma	Cuándo usarla	Cómo se lee en el siguiente paso
`steps.<n>.output`	Un paso posterior necesita la salida de uno concreto.	`"{{steps.0.output.referencia}}"`
`capture` → `context`	Varios pasos posteriores necesitan el mismo valor.	`"{{context.accessToken}}"`
`input` del siguiente paso	Quieres renombrar o seleccionar solo algunos campos.	Declara claves en `input` y léelas como `input.<clave>` (en JavaScript).

Flujo mental:

El paso A asigna un resultado (output en JavaScript, o la respuesta HTTP).
El paso B referencia ese resultado en su input con plantillas.
Opcionalmente, el paso A usa capture para guardar el valor en context con un nombre estable.

Raíces disponibles en plantillas

Expresión	Origen
`{{trigger.body.<campo>}}`	Body JSON del webhook (u otro trigger).
`{{trigger.headers.<nombre>}}`	Headers del disparo, cuando existen.
`{{trigger.query.<campo>}}`	Query string del disparo, cuando existe.
`{{context.<clave>}}`	Valores guardados con `capture` en pasos anteriores.
`{{steps.<indice>.output.<ruta>}}`	Salida de un paso previo (índice desde `0`).

Reglas importantes

Si la plantilla ocupa todo el string ("{{trigger.body.monto}}"), se conserva el tipo original (número, objeto, etc.).
Si la plantilla está dentro de un texto ("Hola {{trigger.body.nombre}}"), el valor se convierte a string.
Una plantilla sin valor resuelve a string vacío ("") cuando está embebida en texto.
Las plantillas se resuelven en input, no dentro del campo code de JavaScript. Pasa datos por input y léelos como input.<campo>.
En browser.use, puedes usar las mismas raíces directamente dentro de task.

Ejemplo completo: JavaScript → HTTP con `steps.N.output`

Webhook de entrada:

{
  "referencia": " REC-1001 ",
  "monto": "1250.50"
}

Automatización de 2 pasos:

{
  "name": "Normalizar y notificar pago",
  "status": "disabled",
  "trigger": { "type": "webhook" },
  "steps": [
    {
      "name": "Normalizar pago",
      "actionKey": "code.javascript",
      "input": {
        "referencia": "{{trigger.body.referencia}}",
        "monto": "{{trigger.body.monto}}"
      },
      "code": "const referencia = String(input.referencia || '').trim();\nconst monto = Number(input.monto);\nif (!referencia) throw new Error('referencia requerida');\nif (!Number.isFinite(monto) || monto <= 0) throw new Error('monto inválido');\noutput = { referencia, monto, moneda: 'MXN' };"
    },
    {
      "name": "Avisar sistema externo",
      "actionKey": "http.request",
      "input": {
        "method": "POST",
        "url": "https://ejemplo.com/hooks/pago",
        "headers": {
          "Content-Type": "application/json",
          "X-Idempotency-Key": "{{steps.0.output.referencia}}"
        },
        "body": {
          "evento": "pago_recibido",
          "referencia": "{{steps.0.output.referencia}}",
          "monto": "{{steps.0.output.monto}}",
          "moneda": "{{steps.0.output.moneda}}"
        }
      }
    }
  ]
}

Qué ocurre:

El paso 0 recibe el trigger por input, limpia datos y deja output = { referencia, monto, moneda }.
El paso 1 lee esos campos con {{steps.0.output.*}} ya resueltos en su input.

Ejemplo completo: JavaScript → JavaScript con `capture` y `context`

Usa capture cuando el valor debe reutilizarse en varios pasos o quieres un nombre estable (context.pago) en lugar de recordar el índice.

{
  "name": "Enriquecer y validar pago",
  "status": "disabled",
  "trigger": { "type": "webhook" },
  "steps": [
    {
      "name": "Normalizar",
      "actionKey": "code.javascript",
      "input": {
        "referencia": "{{trigger.body.referencia}}",
        "monto": "{{trigger.body.monto}}"
      },
      "code": "output = {\n  referencia: String(input.referencia || '').trim(),\n  monto: Number(input.monto)\n};",
      "capture": {
        "pago": {
          "from": "response.body",
          "required": true
        }
      }
    },
    {
      "name": "Validar reglas de negocio",
      "actionKey": "code.javascript",
      "input": {
        "pago": "{{context.pago}}",
        "limite": "{{trigger.body.limite}}"
      },
      "code": "const pago = input.pago || {};\nconst limite = Number(input.limite);\nif (!pago.referencia) throw new Error('falta referencia');\nif (pago.monto > limite) throw new Error('monto excede límite');\noutput = { ok: true, referencia: pago.referencia, monto: pago.monto };"
    },
    {
      "name": "Notificar",
      "actionKey": "http.request",
      "input": {
        "method": "POST",
        "url": "https://ejemplo.com/hooks/pago-validado",
        "headers": { "Content-Type": "application/json" },
        "body": {
          "referencia": "{{context.pago.referencia}}",
          "monto": "{{context.pago.monto}}"
        }
      }
    }
  ]
}

Notas:

En un paso JavaScript, capture.from = "response.body" apunta al valor de output.
En el paso 1, input.pago llega como objeto porque la plantilla ocupa todo el string.
El paso 2 también puede leer {{context.pago.referencia}} sin depender del índice del paso.

Ejemplo: HTTP → JavaScript → HTTP

{
  "name": "Token, transformar y consultar",
  "status": "disabled",
  "trigger": { "type": "webhook" },
  "steps": [
    {
      "name": "Obtener token",
      "actionKey": "http.request",
      "input": {
        "method": "POST",
        "url": "https://ejemplo.com/oauth/token",
        "headers": { "Content-Type": "application/json" },
        "body": {
          "clientId": "{{trigger.body.clientId}}",
          "clientSecret": "{{trigger.body.clientSecret}}"
        }
      },
      "capture": {
        "accessToken": {
          "from": "response.body",
          "path": "access_token",
          "required": true
        }
      }
    },
    {
      "name": "Armar consulta",
      "actionKey": "code.javascript",
      "input": {
        "polizaId": "{{trigger.body.polizaId}}",
        "token": "{{context.accessToken}}"
      },
      "code": "output = {\n  path: `/polizas/${encodeURIComponent(String(input.polizaId))}`,\n  authorization: `Bearer ${input.token}`\n};",
      "capture": {
        "consulta": {
          "from": "response.body",
          "required": true
        }
      }
    },
    {
      "name": "Consultar póliza",
      "actionKey": "http.request",
      "input": {
        "method": "GET",
        "url": "https://ejemplo.com{{context.consulta.path}}",
        "headers": {
          "Authorization": "{{context.consulta.authorization}}"
        }
      }
    }
  ]
}

`capture`: contrato

"capture": {
  "accessToken": {
    "from": "response.body",
    "path": "token",
    "required": true
  }
}

Campo	Descripción
`from`	`response.body`, `response.headers` o `response.status`.
`path`	Ruta con puntos dentro de esa fuente (opcional). Si omites `path`, capturas el objeto completo.
`required`	Si es `true` y falta el valor, el paso falla.
`maxBytes`	Tope opcional del valor capturado.

Buen ejemplo vs mal ejemplo

Bien: pasar salida del paso 0 al paso 1

{
  "steps": [
    {
      "name": "Preparar",
      "actionKey": "code.javascript",
      "input": { "nombre": "{{trigger.body.nombre}}" },
      "code": "output = { nombre: String(input.nombre || '').trim() };"
    },
    {
      "name": "Enviar",
      "actionKey": "http.request",
      "input": {
        "method": "POST",
        "url": "https://ejemplo.com/hooks/hola",
        "headers": { "Content-Type": "application/json" },
        "body": { "nombre": "{{steps.0.output.nombre}}" }
      }
    }
  ]
}

Mal: asumir variables globales entre pasos

{
  "steps": [
    {
      "actionKey": "code.javascript",
      "code": "nombreNormalizado = 'María'; output = { ok: true };"
    },
    {
      "actionKey": "code.javascript",
      "code": "output = { nombre: nombreNormalizado };"
    }
  ]
}

Cada paso corre aislado. El segundo no ve nombreNormalizado. Debes publicar el valor en output (y leerlo con steps.0.output o capture/context).

Mal: plantilla dentro de `code`

{
  "actionKey": "code.javascript",
  "code": "output = { referencia: '{{trigger.body.referencia}}' };"
}

Esto no interpola el trigger. Declara "referencia": "{{trigger.body.referencia}}" en input y usa input.referencia.

Mal: índice de paso incorrecto

Si insertas un paso al inicio, los índices cambian. {{steps.1.output.x}} puede dejar de apuntar al paso que creías. Para valores reutilizados, prefiera capture + {{context.x}}.

Triggers de contacto o tablero

Si el disparo viene de un contacto o registro, usa la bolsa values:

Trigger	Ruta típica
Registro creado (`database_record_created`)	`{{trigger.body.record.values.<fieldId>}}`
Registro actualizado (`database_record_updated`)	`{{trigger.body.record.values.<fieldId>}}`
Contacto creado/actualizado	`{{trigger.body.contact.values.<fieldId>}}`

Metadatos del sobre (por ejemplo trigger.body.record.id) viven fuera de values. Por ejemplo, este input entrega a un paso HTTP el registro y dos de sus campos:

{
  "recordId": "{{trigger.body.record.id}}",
  "estado": "{{trigger.body.record.values.estado}}",
  "responsable": "{{trigger.body.record.values.responsable}}"
}

​Tres formas de pasar datos entre pasos

​Raíces disponibles en plantillas

​Reglas importantes

​Ejemplo completo: JavaScript → HTTP con steps.N.output

​Ejemplo completo: JavaScript → JavaScript con capture y context

​Ejemplo: HTTP → JavaScript → HTTP

​capture: contrato

​Buen ejemplo vs mal ejemplo

​Bien: pasar salida del paso 0 al paso 1

​Mal: asumir variables globales entre pasos

​Mal: plantilla dentro de code

​Mal: índice de paso incorrecto

​Triggers de contacto o tablero

​Relacionado