Process Environment Variables

ProcessFlow injects runtime variables into every step so your code can access input data, tenant context, and platform services without manual bootstrapping. Variable names are case-sensitive. Some services are null or disabled unless the step’s sandbox profile grants the matching capability (for example file access or connector execution).

Input and output context

Identity and process metadata

WebApp and HTTP request context

These fields are populated when the process is triggered from a WebApp (form POST, webhook-style submission). They are typically empty or absent for API-only or scheduled triggers.

Do not use server globals such as $_SERVER — they are blocked in the sandbox. Use the injected fields above instead.

Platform services

Prefer tenantDb and integration over low-level or deprecated APIs.

Files, documents, and OCR

Tenant-relative paths only (for example platforms/25/receipts/invoice.pdf). See PDF OCR and Image OCR.

Logging and the tf namespace

JavaScript and TypeScript steps receive a capability-aware tf object. Prefer tf.* in new snippets; legacy root globals remain for migrated PHP-style code and are aliased on tf where applicable.

tf core members

tf service aliases

The same objects as the root globals are also on tf: tf.tenantDb, tf.integration, tf.api, tf.datapool, tf.llm, tf.email, tf.notification, tf.jwt, tf.files, tf.keystore, tf.pdfOcr, tf.imageOcr, tf.documentReview, tf.db ( /root only).

Full method lists, capability matrix, async integration patterns, and examples: Process sandbox tf API reference.

Tenant file helpers

When the file capability is enabled, these functions are also injected (not objects on a service):

file_get_contents, file_put_contents, file_exists, mkdir, read, write, unlink, copy, rename, glob, and related fopen / fread / fwrite helpers.

Paths must stay inside tenant storage boundaries. Include process_execution_id in generated paths to avoid collisions between concurrent runs.

Internal authentication (advanced)

The api service applies execution auth automatically when app_url and auth context are configured.

Handle optional context safely

Some helpers are context-dependent:

• files and keystore may be null when the step profile does not grant file or secret access.
• WebApp HTTP fields (raw_input, http_headers, …) appear only for WebApp-triggered runs.
• Service methods throw a clear error when the step’s sandbox capability disables that feature.

Guard early and return structured errors so downstream steps are not left with ambiguous failures.

type StepInput = { filename?: string };

function buildOutputPath(input: StepInput, executionId: string, filesService: unknown) {
  if (!input.filename) {
    return { success: false, error: { code: "MISSING_FILENAME", message: "filename is required" } };
  }
  if (!filesService) {
    return { success: false, error: { code: "NO_FILES_SERVICE", message: "file context is not available" } };
  }

  return {
    success: true,
    data: { relative_path: `public_docs/${executionId}/${input.filename}` },
  };
}

Verify runtime context through API execution

When testing variable usage, execute a process through the API with explicit input_data and inspect the execution result.

curl -X POST "https://<YOUR_DOMAIN>/api/v1/processflow?action=execute-process" \
  -H "X-API-Key: <API_KEY>" \
  -H "X-Tenant-ID: <TENANT_ID>" \
  -H "Content-Type: application/json" \
  -d '{
    "process_id": "<ENTITY_ID>",
    "input_data": {
      "filename": "report.pdf"
    },
    "async": false
  }'

{
  "success": true,
  "data": {
    "execution_id": "exec_0f8e21a7",
    "status": "completed"
  }
}

Keep variable usage predictable

Prefer injected services over blocked low-level patterns. Store secrets in keystore or tf.keystore, not in source code. For WebApp-heavy workflows, see WebApp functions guide. For sandbox limits, see Sandbox guardrails. For the full tf API, see Process sandbox tf API reference.

Treat these names as a stable contract between your process design and the execution engine. Clear input validation, tenant-scoped service usage, and structured return payloads make step behavior easier to maintain as workflows grow.