Custom JavaScript Node

The Custom JavaScript node allows you to execute custom JavaScript code during flow execution. It is ideal for data transformations, complex calculations, and logic not covered by native nodes.

In addition to plain JavaScript, this node can also work with already-open Web and Mobile sessions, allowing you to run advanced automation with Playwright and Appium directly from code.

Overview

Configuration

The code editor uses the Monaco Editor (same as VS Code) with:

• Syntax highlighting
• Autocomplete for steps, variables, web, mobile, page, app, return, console.log
• Syntax validation

Execution Context

The code has access to:

Accessing data from previous nodes

// Output from an HTTP Request
const userData = steps["http-request"].outputs.json;
const userName = userData.name;

// Output from a PostgreSQL query
const rows = steps["postgres-query"].outputs.rows;
const firstUser = rows[0];

// Output from web extraction
const title = steps["web-flow"].outputs.extracts.pageTitle;

Accessing variables

const apiUrl = variables.API_URL;
const environment = variables.ENVIRONMENT;

Web and Mobile Sessions

The Custom JavaScript node does not automatically create a Web or Mobile session. It uses a session that was already opened by a previous node.

Web session

To use web, page, context, or browser, you need an active Web session created by a node such as:

• Web Flow
• Smart Locators

Mobile session

To use mobile, app, or client, you need an active Mobile session created by a node such as:

• Mobile Flow

Practical rule

• Use web when you want to extend an already-open Web automation
• Use mobile when you want to extend an already-open Mobile automation
• If there is no active session, these APIs will fail

Web Automation with Playwright

The web namespace exposes the current Web session and advanced utilities powered by Playwright.

web namespace methods

Object returned by web.current() and web.session()

Most common page methods

The page object is a Playwright instance. Common methods include:

Web screenshots

By default, web.screenshot() captures only the current viewport, following the same behavior as the Web nodes.

await web.screenshot("current-page");

To capture the full page:

await web.screenshot("full-page", { fullPage: true });

web.run(...)

web.run(...) is the recommended way to execute advanced code against the Web session. The callback receives:

Web example: validate products and take a screenshot

return await web.run(async ({ page, expect }) => {
  await page.goto('https://automationexercise.com/products', {
    waitUntil: 'domcontentloaded'
  });

  const products = page.locator('.features_items .product-image-wrapper');
  await expect(products).toHaveCount(34);

  await web.screenshot('web-products');

  return {
    url: page.url(),
    title: await page.title(),
    productCount: await products.count()
  };
});

Web example: use the current session without navigating

return await web.run(async ({ page }) => {
  return {
    url: page.url(),
    title: await page.title()
  };
});

Web example: use the global page alias

await page.goto('https://example.com');
await web.screenshot('example-home');

return {
  title: await page.title(),
  url: page.url()
};

Mobile Automation with Appium

The mobile namespace exposes the current Mobile session and advanced utilities powered by Appium.

mobile namespace methods

Object returned by mobile.current() and mobile.session()

app and client

The main Mobile name is app.
client still exists for compatibility, but app is the recommended usage.

Methods exposed in app

Mobile screenshots

await mobile.screenshot('mobile-current-screen');

mobile.run(...)

mobile.run(...) is the recommended way to execute advanced code against the Mobile session. The callback receives:

Mobile example: tap by coordinates and take a screenshot

return await mobile.run(async ({ app, sessionId }) => {
  const source = await app.getPageSource(sessionId);

  await app.tapAt(sessionId, 200, 400);
  await mobile.screenshot('mobile-after-tap');

  return {
    sessionId,
    sourceLength: source.length,
    tapped: true
  };
});

Mobile example: click by accessibility id

return await mobile.run(async ({ app, sessionId }) => {
  const elementId = await app.findElement(sessionId, 'accessibility id', 'login-button');
  await app.elementClick(sessionId, elementId);

  await mobile.screenshot('login-button-clicked');

  return {
    clicked: true,
    elementId
  };
});

Mobile example: use the global app alias

const current = mobile.current();
const source = await app.getPageSource(current.sessionId);

return {
  sessionId: current.sessionId,
  sourceLength: source.length
};

Returning Values

The code must return a value using return. The returned value is available in the outputs:

// Return a simple value
return "Hello World";

// Return an object
return {
  fullName: steps["Query"].outputs.rows[0].first_name + " " + steps["Query"].outputs.rows[0].last_name,
  isAdmin: steps["Query"].outputs.rows[0].role === "admin"
};

// Return an array
return steps["Query"].outputs.rows.map(row => row.email);

Returning the result from web.run() and mobile.run()

If you want the value returned inside web.run(...) or mobile.run(...) to appear in outputs.result, the main script must also return that value:

const result = await web.run(async ({ page }) => {
  return { url: page.url() };
});

return result;

Or directly:

return await mobile.run(async ({ app, sessionId }) => {
  await app.tapAt(sessionId, 200, 400);
  return { tapped: true };
});

Outputs

Accessing the result

{{ steps["custom-js"].outputs.result }}
{{ steps["custom-js"].outputs.result.fullName }}
{{ steps["custom-js"].outputs.result[0] }}

Practical Examples

Transform API data

const items = steps["http-request"].outputs.json.items;

// Filter and transform
const activeItems = items
  .filter(item => item.active)
  .map(item => ({
    id: item.id,
    name: item.name.toUpperCase(),
    price: (item.price * 1.1).toFixed(2)
  }));

return {
  items: activeItems,
  count: activeItems.length,
  totalPrice: activeItems.reduce((sum, item) => sum + parseFloat(item.price), 0)
};

Generate test data

const timestamp = Date.now();
return {
  email: `test-${timestamp}@example.com`,
  username: `user_${timestamp}`,
  password: `Pass${timestamp}!`
};

Complex validation

const response = steps["API Check"].outputs.json;
const dbRecord = steps["DB Query"].outputs.rows[0];

const validations = [];

if (response.name !== dbRecord.name) {
  validations.push(`Name mismatch: API="${response.name}" DB="${dbRecord.name}"`);
}

if (response.email !== dbRecord.email) {
  validations.push(`Email mismatch: API="${response.email}" DB="${dbRecord.email}"`);
}

return {
  valid: validations.length === 0,
  errors: validations,
  errorCount: validations.length
};

Format a report

const runs = steps["Query Runs"].outputs.rows;

const summary = {
  total: runs.length,
  passed: runs.filter(r => r.status === 'success').length,
  failed: runs.filter(r => r.status === 'failed').length,
  passRate: 0
};

summary.passRate = ((summary.passed / summary.total) * 100).toFixed(1) + '%';

return summary;

Plain JavaScript

const now = new Date().toISOString();
const total = [10, 20, 30].reduce((sum, value) => sum + value, 0);

return {
  now,
  total,
  average: total / 3
};

Limitations

• The code runs in a sandbox environment
• There is no access to:
  • File system (fs)
  • Node.js modules via require / import
  • process.env directly
• For environment variables, use variables
• For Web and Mobile interactions, there must already be an active session
• client is still supported, but app is the recommended Mobile name

fetch is available. Even so, for structured HTTP flows that are easier to maintain, prefer the HTTP Request node.

Tips

• Use descriptive node names: "Transform Data", "Generate Credentials", "Validate Response", "Advanced Web Code", "Advanced Mobile Code"
• Always return a value — without return, the output will be undefined
• For debugging, use console.log() — messages appear in the node logs
• Monaco Editor offers autocomplete — type steps., web., or mobile. to see available options
• For advanced Web automation, prefer web.run(...)
• For advanced Mobile automation, prefer mobile.run(...)
• Use web.screenshot() and mobile.screenshot() when you need extra evidence
• Use it to transform data between nodes and to solve advanced cases not covered by visual nodes