Handler context

The second argument to every handler. An HTTP function's handler receives an HttpContext: caller identity, the function's own platform identity, path parameters, and request headers. A job-only function's handler receives a JobContext. FunctionContext is a deprecated alias of HttpContext.

import type { HttpContext } from "@uipath/coded-functions-js-sdk";

Interface

interface HttpContext {
  user: IdentityContext | null;
  robot: RobotContext | null;
  platform: PlatformContext | null;
  params: Record<string, string>;
  headers: Record<string, string>;
}

JobContext

A job-only function's handler receives a JobContext: user, robot and platform, without params and headers.

import type { JobContext } from "@uipath/coded-functions-js-sdk";

user

The identity of the caller. null if the platform cannot identify the caller (unauthenticated request).

A job invocation has no caller, so ctx.user?.sub and ctx.user?.accessToken are both undefined there. Guard on ctx.user?.accessToken rather than on ctx.user itself, and use ctx.robot.accessToken for a job's outbound calls.

IdentityContext

interface IdentityContext {
  sub: string;                     // caller's user ID
  name?: string;                   // display name, if present in claims
  email?: string;                  // email, if present in claims
  accessToken?: string;            // caller's OAuth token (from Authorization header)
}

accessToken

The OAuth token from the caller's Authorization: Bearer header. Use for delegated calls to Orchestrator — the caller's own folder permissions apply.

if (!ctx.user?.accessToken) {
  throw new FunctionError("Not authenticated", 403);
}
const sdk = new UiPath({ secret: ctx.user.accessToken, ... });

robot

The function's own platform identity — the serverless robot it runs as. null on local runs.

RobotContext

interface RobotContext {
  key: string | null;          // serverless robot key
  accessToken: string | null;  // platform-issued workload token (~24h RS256 JWT)
}

accessToken

A platform-issued RS256 JWT (sub_type: robot.user, ~24h TTL) for the function's service account. Use for Secret Vault pattern — reads assets without requiring the caller to have folder access.

Availability:

Context	Available?
HTTP trigger (deployed)	Yes
Job invocation (deployed)	Yes
Local serve	No — use UIPATH_ACCESS_TOKEN in .env

const token =
  ctx.robot?.accessToken ||
  process.env["UIPATH_ACCESS_TOKEN"] ||
  "";

key

The serverless robot's key. Required by Orchestrator's per-robot endpoints — notably GetRobotAssetByNameForRobotKey, the only endpoint that releases a Credential asset's username and password (the OData asset endpoints return those fields empty). See Calling Orchestrator — Credential assets are not readable through the SDK.

platform

Trusted platform coordinates for outbound UiPath calls, injected by the runtime. Use these instead of caller-forwarded input fields — input is caller-controlled and can redirect your Orchestrator calls.

PlatformContext

interface PlatformContext {
  baseUrl: string;           // bare authority, e.g. "https://cloud.uipath.com"
  orgId: string;             // organization id (GUID, not slug)
  tenantId: string;          // tenant id (GUID, not slug)
  folderKey: string | null;  // folder key of the invocation, if any
}

Availability:

Context	Available?
HTTP trigger (deployed)	Yes — from handler-authored headers
Job invocation (deployed)	Yes — from the runtime context (requires a handler that writes the platform fields; null on older handlers)
Local serve	Only with UIPATH_BASE_URL, UIPATH_ORG_ID, UIPATH_TENANT_ID set
Local run	No — run reads the runtime-context file, never the environment

platform is all-or-nothing: it is null unless baseUrl, orgId, and tenantId are all available. folderKey can be null independently (folderless invocation).

if (!ctx.platform) {
  throw new FunctionError("Platform context unavailable — local dev: set UIPATH_BASE_URL/UIPATH_ORG_ID/UIPATH_TENANT_ID", 500);
}
const sdk = new UiPath({
  baseUrl: ctx.platform.baseUrl,
  orgName: ctx.platform.orgId,
  tenantName: ctx.platform.tenantId,
  secret: token,
});

The org-scoped URL (as sent in X-UiPath-Url) is ${baseUrl}/${orgId}/${tenantId}.

params

Path parameters from :param segments in the function's path.

// defineFunction({ path: "/invoices/:id/approve" })
const invoiceId = ctx.params.id;   // "INV-001"

headers

All request headers, with lowercase keys.

const auth = ctx.headers["authorization"];   // "Bearer eyJ..."
const type = ctx.headers["content-type"];

Typing helper functions

Import the context type when you split handler logic into typed helper functions. Type the helper's ctx as JobContext when it reads only user, robot or platform, so HTTP and job-only handlers can both pass their context to it. Use HttpContext when it reads params or headers.

import type { JobContext } from "@uipath/coded-functions-js-sdk";

interface MyInput {
  id: string;
}

// The same interface declares the contract (input: defineSchema<MyInput>()) and types the helper.
async function processItem(input: MyInput, ctx: JobContext) {
  const userId = ctx.user?.sub ?? "anonymous";
  // ...
}

Without the explicit import, the only alternative is ctx: any, which loses all type safety.

Usage example

interface ExampleOutput {
  userId: string;
  resourceId: string;
}

export default defineFunction({
  name: "example",
  method: "POST",
  path: "/example/:id",
  output: defineSchema<ExampleOutput>(),
  handler: async (input, ctx) => {
    // Identity
    const userId = ctx.user?.sub ?? "anonymous";

    // Path param
    const resourceId = ctx.params.id;

    // Token selection
    const token =
      ctx.robot?.accessToken ||
      process.env["UIPATH_ACCESS_TOKEN"] ||
      "";

    return { userId, resourceId };
  },
});