Make.com Code App: Run JavaScript and Python Inside Your Scenarios

Yes, you can write code in Make.com. The Make Code App is a native module that executes JavaScript or Python directly inside your scenarios — no webhooks, no external services, no Lambda functions required.

Contains affiliate links. Disclosure.

Make has always been a visual automation platform, and for 90% of use cases visual modules cover everything. But every Make power user eventually hits the same wall: a transformation that is too complex for the built-in functions, a string manipulation that would take 14 chained modules to replicate, or a cryptographic signature that simply cannot be expressed visually. The Code App closes that gap.

This guide covers what the Code App is, when to reach for it, how to write both JavaScript and Python in Make, and five practical examples you can copy into your own scenarios today.

---

What is the Make Code App?

The Make Code App is a native Make module — no custom app installation needed — that runs arbitrary JavaScript (Node.js runtime) or Python inside a Make scenario execution. It was announced at Waves '25 alongside Make Grid and AI Agents as part of Make's push toward what they call "pro-code + no-code" hybrid automation.

From Make's official blog: "Run native JavaScript and Python scripts inside your automation scenarios to handle complex data transformations and custom logic without external services."

The module takes inputs you define, executes your code, and returns a structured output that downstream modules consume like any other Make bundle.

Key characteristics:

Feature	Detail
Languages supported	JavaScript (Node.js), Python
Execution environment	Sandboxed, isolated per run
Input access	Via a bundle object you configure
Output	Structured key-value pairs you define
External network calls	Not supported inside Code App
Use case	Transformation, calculation, logic — not HTTP requests

---

When to Use Code App vs. Visual Modules

The Code App is not a replacement for Make's 3,000+ app modules. Use it surgically when visual modules create unnecessary complexity or simply cannot express the logic.

Scenario	Visual Modules	Code App
Rename a field	✅ Map it directly	Overkill
Extract email from a string	✅ Use contains, split	Fine either way
Parse complex regex from a scraped field	❌ Multi-step, fragile	✅ One match() call
Generate an HMAC-SHA256 API signature	❌ Not possible visually	✅ crypto module
Flatten a deeply nested JSON object	❌ Requires iterator chains	✅ Recursive function
Calculate business days between two dates	❌ Complex date arithmetic	✅ Clean loop logic
Base64 encode/decode a value	✅ Built-in function exists	Not needed
Convert CSV string to JSON array	❌ No native module	✅ split + map

Rule of thumb: if you need more than 3 chained Set Variable / Text Aggregator / Array operations to express a transformation, write it as code instead.

---

Setting Up the Code App in a Scenario

1. Open your scenario in Make.com.
2. Click the + button to add a module.
3. Search for "Code" — the Code App appears as a first-party module in the Apps list.
4. Select your language: JavaScript or Python.
5. Define your input variables — these are the values from previous modules you want to pass into your code.
6. Write your code in the editor.
7. Define your output variables — the keys your code returns and that downstream modules can use.
8. Run the scenario to test.

The editor supports syntax highlighting and basic error output in the scenario execution log.

---

JavaScript in Make: Structure and Syntax

The module contract

Your JavaScript code runs inside a function context. Make passes your defined input variables as named constants. You return results by calling return with an object containing the keys you declared as outputs.

// Make passes your input variables as direct constants
// e.g., if you defined an input called "rawText", it's available as rawText

const extractedEmails = rawText.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g) || [];

return {
  emails: extractedEmails,          // Array output
  count: extractedEmails.length     // Number output
};

Available JavaScript APIs

The Code App runs a sandboxed Node.js environment. Available built-ins include:

• crypto — HMAC, SHA256, MD5, Base64
• JSON — parse, stringify
• Standard array/string/math methods
• Buffer — binary data handling
• Date — date parsing and arithmetic

External HTTP calls (fetch, axios, require('http')) are not available inside the Code App. Use a separate HTTP module in your scenario for API calls, pass the response as an input to Code App for transformation.

---

Python in Make: Structure and Syntax

The Python runtime follows the same pattern — inputs arrive as named variables, outputs are returned via a dictionary.

# Input variable: raw_date_string (e.g., "March 15, 2026")
# Output: iso_date, days_until

from datetime import datetime, date

parsed = datetime.strptime(raw_date_string, "%B %d, %Y").date()
today = date.today()
delta = (parsed - today).days

return {
    "iso_date": parsed.isoformat(),     # "2026-03-15"
    "days_until": delta                 # Integer
}

Available Python libraries in the sandboxed environment include Python's standard library (datetime, json, re, math, hashlib, base64, collections). Third-party packages like pandas or requests are not available — the Code App is a transformation layer, not a full script runner.

---

Practical Examples

Example 1: Regex Field Extraction

Problem: You receive a customer support ticket body as plain text. You need to extract order IDs in the format ORD-XXXXXX.

// Input: ticketBody (string)
// Output: orderIds (array), primaryOrderId (string)

const matches = ticketBody.match(/ORD-\d{6}/g) || [];

return {
  orderIds: matches,
  primaryOrderId: matches[0] || ""
};

Without Code App, extracting multiple matches from a string requires iterator modules and conditional filtering — 6-8 modules for what is two lines of JavaScript.

---

Example 2: Business Day Calculation

Problem: You need to calculate the due date 5 business days from a project start date, skipping weekends. Make's date functions operate on calendar days only.

// Input: startDateISO (string, e.g. "2026-03-15")
// Output: dueDateISO (string)

function addBusinessDays(start, days) {
  let date = new Date(start);
  let added = 0;
  while (added < days) {
    date.setDate(date.getDate() + 1);
    const day = date.getDay();
    if (day !== 0 && day !== 6) { // Skip Sunday (0) and Saturday (6)
      added++;
    }
  }
  return date.toISOString().split('T')[0];
}

return {
  dueDateISO: addBusinessDays(startDateISO, 5)
};

---

Example 3: JSON Flattening for CRM Import

Problem: An API returns deeply nested JSON. Your CRM import expects flat key-value pairs. Make's JSON parsing modules handle one level of nesting but not recursive structures.

// Input: nestedJson (string — JSON payload from HTTP module)
// Output: flatJson (string — flat key-value pairs)

function flatten(obj, prefix = '', result = {}) {
  for (const [key, value] of Object.entries(obj)) {
    const newKey = prefix ? `${prefix}_${key}` : key;
    if (value && typeof value === 'object' && !Array.isArray(value)) {
      flatten(value, newKey, result);
    } else {
      result[newKey] = Array.isArray(value) ? JSON.stringify(value) : value;
    }
  }
  return result;
}

const parsed = JSON.parse(nestedJson);
const flat = flatten(parsed);

return {
  flatJson: JSON.stringify(flat),
  keyCount: Object.keys(flat).length
};

---

Example 4: HMAC-SHA256 API Signature

Problem: You need to call a payment gateway API that requires an HMAC-SHA256 request signature. This cryptographic operation is completely impossible with visual Make modules.

// Inputs: payload (string), secretKey (string)
// Output: signature (string), timestamp (number)

const crypto = require('crypto');

const timestamp = Date.now();
const messageToSign = `${timestamp}.${payload}`;

const hmac = crypto.createHmac('sha256', secretKey);
hmac.update(messageToSign);
const signature = hmac.digest('hex');

return {
  signature: signature,
  timestamp: timestamp
};

This output feeds directly into your HTTP module's header configuration — no external signing service needed.

---

Example 5: CSV String to Structured Array

Problem: A Google Sheets row contains pipe-delimited product tags ("electronics|audio|wireless|premium"). You need this as a JSON array for a downstream API call.

// Input: tagString (string, pipe-delimited)
// Output: tagArray (array), tagCount (number)

const tags = tagString
  .split('|')
  .map(t => t.trim())
  .filter(t => t.length > 0);

return {
  tagArray: tags,
  tagCount: tags.length
};

---

Code App vs. Make's Custom Functions

Make has two separate code-execution features. They are not the same:

Feature	Code App	Custom Functions
Location	Inside a scenario as a module	Team-level reusable functions
Languages	JavaScript, Python	JavaScript only
Scope	Single scenario execution	Callable from any scenario via formula
Best for	Complex per-scenario logic	Reusable transformations (like a helper library)
Inputs	Defined bundle variables	Function arguments
State	Stateless, run-once	Stateless, callable anywhere

If you find yourself copying the same Code App logic across 5 scenarios, extract it into a Custom Function instead.

---

Limitations to Know Before You Build

No external network access. The Code App cannot make HTTP requests. It is a pure transformation layer. Use an HTTP module before or after to handle API calls, then pass data through Code App for processing.

Execution timeout. Long-running code (heavy loops, large dataset processing) will hit execution limits. If you need to process thousands of records, use Make's iterator pattern and run one Code App per item.

No persistent state. Each Code App execution is fully isolated. You cannot write to disk, cache results between runs, or maintain session state.

Standard library only. You cannot install npm packages or PyPI packages. If you need a specialized library, consider offloading the logic to an Apify Actor and triggering it via Make's Apify module.

Python version. Python runs on a sandboxed interpreter. Assume Python 3.x with the standard library available, but avoid version-specific syntax features without testing.

---

Connecting Code App to Apify for Heavy Data Processing

For transformations that exceed what Code App can handle in-scenario (large datasets, browser automation, proxy-dependent extraction), the Make + Apify combination is the standard architecture.

1. Make triggers an Apify Actor via the Apify module — passing query parameters, URLs, or configuration.
2. Apify handles the heavy work — browser automation, proxy rotation, large-scale extraction.
3. Make receives the output dataset via webhook or polling.
4. Code App processes the results — cleaning, transforming, or reshaping the Apify output for downstream CRM or database injection.

See the Apify + Make.com Integration guide for complete workflow patterns.

---

Frequently Asked Questions

Yes. The Make Code App is a native module that runs JavaScript or Python directly inside your scenario. You define input variables (mapped from previous modules), write your transformation logic, and return structured outputs that downstream modules consume. No external services, webhooks, or Lambda functions are required.

Yes. The Code App supports both JavaScript (Node.js) and Python. Python runs with the standard library available — datetime, json, re, math, hashlib, base64, and collections are all usable. Third-party packages like pandas or requests are not available inside the Code App's sandboxed environment.

Custom Functions are team-level reusable helpers written in JavaScript — callable from any scenario using Make's formula syntax. The Code App is a scenario module that runs JavaScript or Python once per execution, handling logic too complex for visual modules. Use Custom Functions for reusable utilities; use Code App for scenario-specific transformation or logic that cannot be expressed visually.

No. The Code App is a pure transformation module — it cannot make outbound network calls. For HTTP requests, use Make's HTTP module or a dedicated app connector before or after the Code App. Pass the API response as an input variable to Code App for transformation.

Check the current plan requirements on the Make pricing page. Features and plan availability change regularly, so verify directly with Make before building workflows that depend on Code App. The module was announced as part of Make's Waves '25 product releases.

---

Start Building with Make Code App

The Make Code App removes the last real friction point in visual automation — the moment where your logic outgrows what modules can express. JavaScript for most cases, Python when your team lives in it.

Start building on Make.com →

If your workflows involve web data extraction, pair Make with Apify for the full pro-code + no-code stack: Apify handles the hard scraping work, Make orchestrates the pipeline and business logic, Code App cleans and transforms the results.