How to Run JavaScript in Make.com (2026): Code, Costs & Limits

Step by step

How to run JavaScript in Make.com

The simplest current setup uses Make’s native Code module. Make documents the module as a paid-plan feature with a built-in editor, input mapping, output handling and isolated execution.

A simple Make Code example

Suppose the previous module supplies two dates. The Code module can calculate the number of days between them and return a structured result.

// Values mapped from previous Make modules
const { start_date, end_date } = input;

const start = new Date(start_date);
const end = new Date(end_date);

if (
  Number.isNaN(start.getTime()) ||
  Number.isNaN(end.getTime())
) {
  throw new Error("Invalid date");
}

const days =
  Math.floor(
    (end.getTime() - start.getTime()) /
    (1000 * 60 * 60 * 24)
  );

return {
  days
};

Make’s current documentation uses the same general input-object pattern and provides a date-difference example in its official Code documentation. See Make Code documentation →

What you actually get

What Make Code provides

Make Code is more capable than the old “paste a tiny JavaScript snippet” description suggests. The current documentation describes an isolated sandbox, an editor with autocompletion and error highlighting, access to standard output and error logs, dynamic code input, scenario blueprint sharing and support for both JavaScript and Python.

Current limits

Make Code runtime limits in 2026

The current official feature table gives two runtime environments. Core, Pro and Teams receive the standard sandbox, while Enterprise receives the larger execution environment.

Source: Make Code — official application documentation .

The part most tutorials skip

How much does JavaScript cost in Make.com?

Make’s general billing model is credit-based. Most non-AI module actions use a fixed rate, normally one credit per operation. Make Code is a specific exception: it consumes 2 credits per second of code execution.

That means execution time matters. A two-second Code execution consumes about four credits; a five-second execution consumes about ten; a ten-second execution consumes about twenty.

The important distinction is that these are Code-module credits, not the total credits for your complete scenario. Other modules may consume additional credits.

Make’s official pricing also states that credit usage varies by feature and that Make Code is an exception to the normal one-credit-per-operation model. See Make’s current credit documentation →

Dependencies

Can you install NPM packages in Make Code?

This is one of the biggest practical differences between Make plans.

Make currently documents standard JavaScript libraries including moment, moment-timezone and lodash. For Python, it documents pendulum, toolz and requests.

Enterprise adds the ability to import custom dependencies. Make’s current documentation shows an axios example using the additional-dependencies setting.

Security

Can Make Code call APIs?

Yes. Make’s official examples demonstrate API requests from Code, including JavaScript using fetch().

But Make explicitly recommends considering the standard HTTP module for API requests when credentials need protection. The reason is that Code execution, logging and mapped input can expose information depending on how the scenario is built.

const response =
  await fetch("https://example.com/api/data");

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}`
  );
}

const data = await response.json();

return data;

For API keys, OAuth credentials and other secrets, put authentication in the appropriate Make connection or HTTP module whenever that is the safer architecture rather than embedding credentials in code.

External code options

0CodeKit vs 1001fx vs Make Code

External JavaScript services still have a legitimate place. They can be useful where Make Code’s dependency model, execution limits or native feature set do not fit the job.

Sources: 0CodeKit JavaScript Executor and 1001fx Execute JavaScript .

Alternative architecture

What about Latenode?

Latenode is worth considering when JavaScript is becoming a major part of the workflow rather than an occasional helper. Its current platform documentation describes full JavaScript nodes, data passing between nodes, npm imports and an AI assistant for generating, modifying and debugging code.

However, the pricing comparison needs to be updated from older Latenode material. Current Latenode documentation uses CPU seconds rather than the old “one credit per 30 seconds” model for new Pay-As-You-Go accounts. The current Free tier includes 10,000 CPU seconds per month; additional CPU seconds are billed at tiered rates.

Latenode’s current billing documentation also distinguishes wall-clock duration from billed CPU seconds, so a cost comparison should not simply multiply the visible scenario duration by a fixed rate.

Architecture guide

Which JavaScript approach fits which workload?

Practical examples

Useful JavaScript tasks inside Make

1. Filter and transform an array

const items = input.items || [];

const result = items
  .filter(item => Number(item.price || 0) >= 100)
  .map(item => ({
    id: item.id,
    price: Number(item.price)
  }));

return { result };

2. Normalize incoming data

const email =
  String(input.email || "")
    .trim()
    .toLowerCase();

return {
  email,
  valid: /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
};

3. Apply business rules

const amount = Number(input.amount || 0);
const status =
  amount >= 1000
    ? "high"
    : amount >= 250
      ? "medium"
      : "low";

return {
  amount,
  status
};

These are good Code-module workloads because the code produces a compact result that can immediately be mapped into downstream Make modules. Large API orchestration, long-running computation or dependency-heavy applications are different architectural problems.

Reference material

Primary sources used for this guide

Product limits and pricing can change. The following first-party documentation is the source trail behind the factual claims on this page.

Answers

Frequently asked questions about JavaScript in Make.com