How to Run JavaScript in Make.com (And When It’s Cheaper in Latenode)

Make Code vs third-party apps vs Latenode

Running JavaScript with Make’s native Code app

Make’s Code app is currently in open beta and available to accounts on paid plans. Setup is straightforward:

• Drag the Code module into your scenario from the module library.
• Choose JavaScript as the language (Python is also supported in the same module).
• Reference data from previous modules using Make’s standard field mapping, then write your logic in the built-in editor, which includes syntax highlighting and autocompletion.
• Test with “Run once” against real data from earlier in the scenario before saving.
• Map the structured output — JSON, arrays, or plain values — to whatever module comes next.

The module runs in an isolated sandbox, so there’s no server to provision and no separate authentication step. For a script that runs occasionally, this is genuinely the simplest option available.

Why the Code app gets expensive fast

Standard Make modules cost a flat 1 credit per execution, regardless of how long they take to run. The Code app doesn’t follow that rule. It’s billed at 2 credits for every second the script executes, separate from the flat per-module rate everything else uses.

A script that takes 3 seconds to parse a payload and format a response costs 6 credits on its own. Compare that to a standard HTTP or data-formatter module doing similar work for 1 credit, and the code path is already 6 times more expensive before it runs even once at volume.

The third-party workaround: 0CodeKit and 1001fx

Before Make’s own Code app existed, and still today for functions it doesn’t natively cover, the standard workaround has been third-party marketplace apps. 0CodeKit and 1001fx are the two most commonly used — both let a scenario call out to their own service to execute JavaScript, generate PDFs, convert files, or run spreadsheet-style lookups.

The tradeoff is straightforward: these apps require their own separate account, and usage is billed on their own credit or token system, in addition to whatever Make itself charges to call the app as a module.

For a single utility function Make doesn’t have natively, that’s a reasonable price. For a scenario that needs this kind of logic constantly, running two separate billing systems in parallel gets harder to track.

Latenode: one JavaScript node, no code surcharge

Latenode takes a different approach to the same problem. Instead of treating code as a special, higher-cost module, its JavaScript node runs on the same execution-time billing as everything else on the platform.

That’s roughly 1 credit per 30 seconds of processing, whether that time is spent in a native action or in a script you wrote yourself.

The node also comes with a built-in AI Copilot that can generate, explain, and debug the JavaScript for you from a plain-language description, plus direct access to standard NPM packages — over 1.2 million of them — so common tasks like PDF generation or data lookups don’t require a separate third-party app at all.

// data comes from the previous node (e.g. a webhook payload)
const items = data.line_items || [];

// Filter and reshape in one pass — runs as part of a single execution
const highValue = items
  .filter((item) => item.price > 50)
  .map((item) => ({
    sku: item.sku,
    price: item.price.toFixed(2)
  }));

return { highValue };

Looping through the array happens inside the node itself rather than through a separate iterator module, so the whole operation — filter, transform, and return — bills as one execution instead of one charge per item.

Worked cost comparison

Take a script that takes 4 seconds to run — enough time to parse a payload, hit a small lookup, and format a response.

Run that same script 500 times a month and Make’s Code app alone accounts for roughly 4,000 credits — before counting any other module in the scenario. The equivalent Latenode run stays well under 500 credits for the same volume, since the per-second rate for code isn’t priced differently from anything else on the platform.

When to move a JavaScript-heavy scenario to Latenode

Occasional, short scripts inside an otherwise simple Make scenario rarely justify standing up a second platform. The math changes once code becomes a recurring part of how a workflow runs — several seconds of execution time, multiple times a day, inside a loop, or stacked with a third-party app’s own fees on top.

If that describes more than one or two of your scenarios, it’s worth reading through our Latenode Make.com migration guide for the full webhook setup and module-mapping process, rather than migrating this one scenario in isolation.

Frequently asked questions