n8n community nodes, without the toolchain
Point it at an address, say what people should be able to fill in, and download a package n8n installs. No TypeScript, no build step, no n8n on your machine.
Free while in preview. Nothing published without your say-so.
The builder
Most tools make you learn where a value belongs in an HTTP request before you can build anything. Here you drag it, and the address bar above updates as you do.
Try it. Drag Email from Data sent into Filters and watch the address change. That is the whole mental model, and it is the same code the editor runs.
How it works
Name your node, point it at an API, and add the operations you need.
Mistakes surface as you type, against the exact field that caused them.
Run every operation against the real API before you ship. Green means it works, not merely that it parses.
One click. It installs through n8n’s own Settings and Community Nodes dialog, like any other node.
Why this works
Everything a node does lives in a JSON description: which fields the user sees, and where each value goes in the outgoing request.
The only JavaScript in a finished node is a fixed shim that hands that JSON to n8n. It is byte identical for every node except the class name.
So building a node never actually required a compiler. It only looked that way because the official tooling shipped a TypeScript project.
// the entire runtime of a generated node const definition = require('./definition.json'); class Stripe { constructor() { this.description = structuredClone(definition); } } exports.Stripe = Stripe;
Under the hood
We built the pipeline ourselves rather than wrapping tooling that already existed. The engine that checks what you type in the builder is the same one that assembles the package and publishes it.
That matters more than it sounds. Because the builder, the API and the AI drafts all run on one engine, they cannot disagree about what a valid node is. There is no second implementation to fall out of step.
Catches the mistakes that would otherwise surface as a node that installs cleanly and then fails on its first run.
LiveTurns your definition into a complete, installable package. Same input always produces the same output, byte for byte.
LiveRuns each operation against the real API, so you find out before publishing rather than after.
LiveShips the finished node so it installs through n8n’s own dialog, with no manual steps in between.
LiveThe interface itself, running on our own infrastructure.
LiveSign in, keep your nodes, and pick up where you left off across machines.
NextStart from a description or a spec instead of a blank page.
NextPoint at an API’s documentation and say what you want it to do. The builder drafts the node, wires the fields to the right part of each request, and hands it back for you to check before anything ships.
Paste an OpenAPI file, a documentation link, or a single curl command, and start from a working draft instead of a blank page.
Rate limits, retries and the failure cases a given API actually returns, handled without you reading the whole reference.
Nothing is published without you seeing it first. The draft is a starting point, not a decision made on your behalf.
For teams
Everything the builder does is available as an API. Validate a definition, build a package, and publish it, all from your own pipeline.
It suits teams generating nodes in bulk, keeping an internal catalogue in step with an API that changes often, or wiring node builds into CI alongside everything else they ship.
Talk to us about access for your team.
# validate, build and publish from anywhere curl -X POST https://api.nodebuilder.io/validate \ -H 'Content-Type: application/json' \ -d @node.json curl -X POST https://api.nodebuilder.io/publish \ -H 'X-API-Key: ...' \ -d @node.json
Being straight with you
A tool that hides its limits wastes your afternoon before you find them. These are the real ones.
It takes about five minutes, and you will not write a line of code.
Free while in preview.