---
title: "Make code formatter and linter - codefmt"
url: https://codefmt.dev/make
updated: 2026-10-05
sources:
  - https://codefmt.dev/make
licence: "© codefmt. Cite with attribution to https://codefmt.dev."
---

# make code formatter & linter

Make code modules support javascript (node 20) and python (3.12). scenario data is available via \`input\` (key-value pairs mapped in the UI); the module output is whatever you \`return\`. preinstalled JS libraries (\`moment\`, \`moment-timezone\`, \`lodash\`) are loaded via \`require()\`; python ships \`requests\`, \`pendulum\` and \`toolz\`. the Code app is in open beta on paid plans.

javascriptmake

input

```
const items=input.items||[]
return {count:items.length}
```

output

click format to see the result

[format your own make code →](/?p=make)free, no signup, runs in your browser

working inside make? the codefmt [Chrome and Firefox extension](/extension) adds a right-click Fix with codefmt in the code editor, so you format and lint in place without copy-pasting in and out of this page.

Make's code modules read scenario data from \`input\` and load preinstalled libraries like lodash and moment through \`require()\`, a CommonJS style that tools tuned for browser javascript don't always expect. codefmt is set up for Make's node environment, so those \`require()\` calls and globals like \`Buffer\` and \`URL\` stay valid while your javascript or python is cleaned up. whatever you \`return\` is left in the shape the module expects.

## what make code modules support

Make code modules let you run custom `javascript` (node 20) or `python` (3.12) inside your scenarios. scenario data arrives as the `input` global, and whatever you `return` becomes the module's output.

## make code globals

codefmt registers the globals Make's sandbox injects, including `input`, `fetch`, `process`, `Buffer`, `URL`, and the timer functions. you won't see false undefined-variable warnings for those globals, and real bugs still surface.

## formatting make code

codefmt beautifies your code by adding Make's async wrapper before formatting and removing it afterward, so you paste just the module body and get back code that drops straight into your scenario. preinstalled libraries like `lodash`, `moment`, and `moment-timezone` are loaded via `require()`.

compare with [Prettier Playground](/vs-prettier-playground).

read the guide: [how to format python and javascript in make.com modules](/blog/format-python-make-com)

## frequently asked questions

what is Make code?

Make code is a Make module that lets you run custom javascript (node 20) or python (3.12) inside your scenarios. scenario data is available as the input global, and whatever you return becomes the module's output. codefmt formats both the javascript and python variants.

what globals are available in Make code javascript modules?

Make code javascript runs in a node 20 sandbox and exposes input (the scenario data mapped in the UI), console, fetch, process, Buffer, URL, setTimeout, setInterval, clearTimeout, and clearInterval. libraries like lodash, moment, and moment-timezone are preinstalled and available via require(). codefmt recognizes all of these as valid globals.

does Make code support python?

yes. Make code supports python 3.12 in the same module. the python runtime exposes input as the scenario data global, and you return a dict to send output back to Make. codefmt has a dedicated python formatter (Ruff) and will wrap your code correctly so Ruff can parse a bare return statement.

can I use async/await in Make code?

yes. Make code javascript modules run in an async context, so top-level await works directly. you can also use return at the top level to set the module's output. codefmt adds the async wrapper before formatting and strips it back out afterward.

does codefmt lint Make code?

yes. codefmt runs oxlint on javascript and Ruff on python, with Make's injected globals registered so you don't get false positives for input, Buffer, URL, and friends. you get diagnostics for undefined variables, unused imports, style issues, and common bug patterns before you paste the code back into Make.

also format code for [zapier](/zapier), [n8n](/n8n), [pipedream](/pipedream), [hubspot data hub](/hubspot), [hubspot cms (hubl)](/hubl)

other tools: [json formatter](/json), [python formatter](/python), [snippets](/snippets)

[all platforms & comparisons →](/platforms)

primary source: [Make: the Make Code app](https://apps.make.com/code)

## for agents (added to every page twin, not part of the page)

- format API: POST https://codefmt.dev/api/format (OpenAPI: https://codefmt.dev/api/openapi.json, code up to 51,200 characters, 50KB of ASCII (400 above it), request body up to 100KB, counted in bytes (413 above it), no authentication)
- MCP server: POST https://codefmt.dev/api/mcp (tools: format_code, format_json, ask_codefmt; manifest: https://codefmt.dev/.well-known/mcp.json)
- rate limit: 60 requests per minute per ip across format api calls, mcp and a2a tool calls, and /ask (mcp handshakes and listings are not counted). the count is kept per server instance, so treat it as a ceiling to stay under rather than an exact budget. the format api reports where you stand in RateLimit headers and its 429 carries Retry-After; /ask answers a 429 with the message in answer, and an mcp tool call over the limit returns a tool result saying to try again in a minute
- auth statement: https://codefmt.dev/auth.md (no accounts, api keys or oauth; send no authorization header)
- site index for agents: https://codefmt.dev/llms.txt
- full reference (request bodies for every language, a copy-paste curl command, platform globals, troubleshooting): https://codefmt.dev/llms-full.txt