Make Code App vs CustomJS: An Honest Comparison (Pricing, Limits, npm, Reusable Functions)

What does the Make Code app cost per run, and who can use it?

Make documents the Code app at apps.make.com/code (the older help URL redirects there). As of October 2026 the page states:

• 2 credits per second of code execution. Every other Make module costs 1 credit per operation. A script that finishes in 400 ms costs 2 credits; one that runs 5 seconds costs 10.
• Open beta, paid plans only. Core, Pro and Teams customers see the app. On Make's Free plan (1,000 credits per month) it does not appear, and Make notes that pricing can change during the beta.
• Node 20 (20.19.4 at the time of checking) and Python 3.12. Buffer, crypto and outbound HTTP work. Make's own docs recommend the HTTP module instead of Code for API calls so credentials stay in Make connections, which is sound advice, but the capability is there.
• Sandbox: 1 CPU, 512 MB RAM, 30 second cap. Enterprise raises that to 2 CPUs, 1 GB and 300 seconds.
• Libraries: moment, moment-timezone, lodash for JavaScript (pendulum, toolz, requests for Python). Importing anything else is an Enterprise feature.
• No shared functions. Code lives inside each module. To reuse it you copy it, or export and import a blueprint.

For the dollar side of this article we use Make's own base tiers, checked October 2026: Core at $9 per month and Pro at $16 per month, both with 10,000 credits, which works out to roughly $0.90 to $1.60 per 1,000 credits on monthly billing.

What does the CustomJS module cost per run?

The Execute Inline JavaScript module in the CustomJS app for Make is an ordinary Make module from Make's point of view: 1 credit per call, no matter how long the code runs. The execution happens on CustomJS servers and is counted against a request quota there. The timeout is 30 seconds on the free plan and 60 seconds on paid plans.

The honest footnote: this is a second vendor. Your data leaves Make for the duration of the call, you manage one more API key, and the plan fee applies even in a month where you run the module twice. Those are real costs and they belong in the comparison. See /pricing for the current quotas.

Which is cheaper at 1,000 runs per month?

Per run, Make Code costs 2 x seconds credits and CustomJS costs 1 credit plus one request. Multiply by 1,000 runs per month, which is above the CustomJS free tier, so the CustomJS column includes the $9 Pro plan. Dollar figures use the $0.90 to $1.60 per 1,000 credits bracket from Make's Core and Pro base tiers.

Two things move the line. First, volume under 600 runs per month: the CustomJS column drops to the credits alone (no plan fee), and CustomJS is cheaper at every runtime. Second, Make's Free plan: the Code app is not available there at all, so the only way to run code without upgrading Make is an external module. Above those two cases, the table stands, and most scripts people write sit in the first two rows. A 1 second script on Make Code costs 2 credits, and that is fine.

There is also a predictability point that does not show up in averages. A per-second script costs double in the month the upstream API is slow, and the extra credits come out of the pool every other module in the account shares. A per-call module costs the same on a slow day.

What does the same script look like in both?

Here is a typical reshape job: an order comes in from a form with line items as strings, and the next module needs clean numbers, a subtotal, tax and a total. In CustomJS the mapped value arrives as the input variable (a JSON string is parsed for you; a Make collection should go through the JSON app's Transform to JSON module first). Put a Make bundle like this into the Input field:

{
  "orderId": "SO-20481",
  "currency": "EUR",
  "taxRate": "19",
  "items": [
    { "sku": "MUG-01", "qty": "2", "unitPrice": "12,50" },
    { "sku": "TEE-M", "qty": "1", "unitPrice": "24,00" },
    { "sku": "STK-10", "qty": "3", "unitPrice": "1,99" }
  ]
}

The JavaScript Code field, with Return Type set to Object:

// input: the order bundle from the form module (parsed JSON)
const order = typeof input === "string" ? JSON.parse(input) : input;

// "12,50" -> 12.5, "1.299,00" -> 1299
const toNumber = (s) => Number(String(s).replace(/\./g, "").replace(",", "."));

const items = order.items.map((it) => {
  const qty = toNumber(it.qty);
  const unitPrice = toNumber(it.unitPrice);
  return { sku: it.sku, qty, unitPrice, lineTotal: +(qty * unitPrice).toFixed(2) };
});

const subtotal = +items.reduce((sum, it) => sum + it.lineTotal, 0).toFixed(2);
const taxRate = toNumber(order.taxRate) / 100;
const tax = +(subtotal * taxRate).toFixed(2);

return {
  orderId: order.orderId,
  currency: order.currency,
  itemCount: items.reduce((n, it) => n + it.qty, 0),
  items,
  subtotal,
  tax,
  total: +(subtotal + tax).toFixed(2),
};

Output, which Make shows as mappable fields in every following module:

{
  "orderId": "SO-20481",
  "currency": "EUR",
  "itemCount": 6,
  "items": [
    { "sku": "MUG-01", "qty": 2, "unitPrice": 12.5, "lineTotal": 25 },
    { "sku": "TEE-M", "qty": 1, "unitPrice": 24, "lineTotal": 24 },
    { "sku": "STK-10", "qty": 3, "unitPrice": 1.99, "lineTotal": 5.97 }
  ],
  "subtotal": 54.97,
  "tax": 10.44,
  "total": 65.41
}

This script finishes in roughly 120 ms on CustomJS (the median inline script across our runs takes 121 ms). The function body is plain Node and runs unchanged in Make Code once you wire its input the way that module expects; there the run bills 2 credits because it is under a second. For this kind of script, on a paid Make plan, with more than 600 runs a month, Make Code is the cheaper home for it.

Where the two diverge is the first line that needs a package. The following 8 lines pull the product names out of a supplier's HTML price list with cheerio. On CustomJS this runs on the free plan. On Make Code it requires Enterprise, because cheerio is not one of the three bundled libraries:

const cheerio = require("cheerio");

// input: the HTML of a supplier price list, fetched by an HTTP module before this step
const $ = cheerio.load(input);
const products = $("table.prices tr td:first-child")
  .map((i, td) => $(td).text().trim())
  .get();

return { count: products.length, products };

The full package list (axios, cheerio, pdf-lib, jsonwebtoken, jose, uuid, mathjs, moment-timezone, nodemailer, json-2-csv, and more) is at /integration/make/npm-modules.

Where does Make Code win?

• Short scripts at volume on a paid plan. Under 2 seconds and over 600 runs a month, 2 to 4 credits per run beats 1 credit plus a $9 subscription. This describes the majority of code steps: parse a string, reshape a bundle, compute a few fields.
• No second vendor. The code runs inside Make's own sandbox. Nothing leaves the platform, there is no extra account, no extra API key, no extra invoice.
• Python. Make Code runs Python 3.12 with pendulum, toolz and requests. CustomJS executes JavaScript only.
• lodash and moment are already there. If those two cover your needs, the library gap does not affect you.

Where does CustomJS win?

• Reusable stored functions. The Execute Stored Function module calls a function written and versioned at app.customjs.space by name, with named parameters, from any number of scenarios. Fix a bug once and every scenario picks it up. Make Code has no equivalent; the code travels only inside each module or a blueprint export. Teams that adopt stored functions tend to stay: they are our longest-tenured customers, with a median tenure of 15 months.
• npm on every plan, including free. cheerio for HTML, pdf-lib for PDFs, jsonwebtoken and jose for signed tokens, mathjs for real math, nodemailer for mail. On Make this list is one plan tier away (Enterprise).
• Long or waiting scripts. Anything that polls, retries or processes a big payload gets billed per second on Make Code and per call on CustomJS. From about 5 seconds the gap opens; at 15 seconds it is 3x to 4x. The paid timeout is 60 seconds versus Make's 30.
• Make's Free plan. The Code app is not offered there. The CustomJS module is, with 600 requests a month at $0 and 1 of your 1,000 free Make credits per call.
• Pre-built utility modules for the common jobs, so you may not need code at all: Group & Aggregate Array, AI JSON Parser, Format Date & Convert Timezone, HTML to PDF.

How do the two compare feature by feature?

Make facts from apps.make.com/code and make.com/en/pricing, October 2026. CustomJS facts from our plan limits on the same date.

When Make's built-in is enough

A code step of either kind is the wrong tool in these cases:

• One function on one value. formatDate, replace, split, toString and base64 in the mapping panel cost nothing extra and run inside the module that uses them.
• A single total over one array. sum(map(items; price)) or the Numeric Aggregator handles one sum, average, min, max or count without code.
• A plain API call with a connection. The HTTP module keeps the credentials in a Make connection and bills 1 credit. Make itself recommends this over Code for API calls, and we agree.
• Simple branching. Routers and filters are cheaper to read six months later than an if-chain in a script.
• A one-off. If the scenario runs ten times and is then deleted, the cheapest option is whichever one you already have open.

How do I decide in 30 seconds?

• On Make Free? The Code app is not available; CustomJS (600 requests per month, $0) is the way to run code.
• Paid Make plan, script under 2 seconds, more than 600 runs a month? Make Code.
• Under 600 runs a month at any runtime? CustomJS free tier, 1 credit per call.
• Script waits on an API, retries, polls or takes 5 seconds or more? From about 5 seconds CustomJS pulls ahead, at 15 seconds by 3x to 4x.
• Need a package beyond moment or lodash, and you are not on Make Enterprise? CustomJS.
• Same logic in three or more scenarios? A stored function, so there is one copy to maintain.
• Need Python? Make Code.

If your scenario lands in the CustomJS rows, the free plan needs no credit card and the Make module installs from the app directory in a minute.

Create a free CustomJS account