n8n-mcp — the assistant learns n8n nodes and writes the flow for you, ready to use
n8n-mcp gives your assistant the knowledge of n8n nodes, so you can ask for an automation flow in English and get it checked and ready to import. It works without n8n, without an account, and without a key, at the price of telemetry that is open by default and only seven tools if you do not have your own n8n.

What it does
Eight articles in this column showed you tools that touch code. This ninth one shows something that is not code: workflows.
A workflow is a chain of steps that run on their own. Someone fills out a form. You want their answer to go to your email, a row to be added to a spreadsheet, and a phone notification to reach you. Those three steps, tied together, are a workflow. They run without you pressing anything.
n8n is the program where you build such flows by clicking boxes on a canvas, without writing code. Each box is called a node and does one job. One node sends email, one reads a spreadsheet, one asks a service on the internet. You connect them with lines and the flow works.
The term MCP means “a protocol for connecting tools to an assistant.” Think of a socket. Your assistant has one receptacle, and every tool that fits the socket gives it new abilities. The MCP server is the device that plugs into the socket.
This is the problem n8n-mcp solves. n8n has many hundreds of nodes, and your assistant does not know them. It does not know what fields the Slack node wants, or which node is now the right one and which one has been retired. So when you ask it for a flow, it gives you something that looks right and breaks on the first run.
n8n-mcp is an MCP server that gives it that knowledge. You ask for a flow in English, it looks up the real nodes, composes them into a JSON file, and you import that into n8n. It works even if you do not have n8n at all, without an account and without a key; in that form it exposes seven tools: tools_documentation, search_nodes, get_node, validate_node, get_template, search_templates, and validate_workflow.
What it does not do
It does not run flows or host n8n. We built JSON and imported it. You still have to import it into n8n, provide credentials, configure webhooks, and activate the flow. n8n-mcp does not manage keys, secrets, or installations. Do not ask it to fill in credentials or to deploy.
It only knows what the node catalog it has built shows. If you use custom or third-party nodes, or a newer version of n8n, the suggestion may be missing or wrong. It does not write reliable custom code in Function/Code nodes. When a flow needs complex logic, conditions, or fine-grained expressions, manual fixes will be needed.
The check is limited to structure. We saw that it clearly rejects structural errors, but it does not catch runtime errors, API limits, or permissions. Do not send sensitive data into prompts; telemetry sends cleaned text and structures. The trap is to import and trust without checking again. Verify it before production.
Who it is for
For anyone who has repetitive work that is not code.
If you send the same email every time an order closes, or manually copy data from a form into a spreadsheet, that is material for a workflow. And the obstacle is not n8n. It is that you do not know which node to place where, and that you search the documentation one node at a time.
It is also useful for anyone who already has n8n and wants to work faster, without clicking boxes by hand.
It makes no sense if you do not build workflows at all. It is a tool for the job, not for code.
Installation
The package is called n8n-mcp, lives on npm, and the stable version is 2.92.1, published on 6 October 2026. Its license is MIT, one of the most permissive there is: you can use it in commercial work without being forced to give away your own code. It is written in TypeScript.
It needs Node on the machine. Check that you have it, from any folder you like:
node --version
Then run it without installing it permanently:
npx -y n8n-mcp
The first time, npx downloads the package, and the server builds a local database of n8n nodes. That takes about a minute and needs an internet connection. From the second run onward it starts instantly, and no network is needed.
If you do not want telemetry, turn it off with one command:
npx n8n-mcp telemetry disable
Below I explain what it sends, because that is not trivial.
How to use it in each LLM
n8n-mcp is an MCP server, so the connection looks the same in all programs. What changes is where you put the configuration. The configuration it asks for in all of them is the same: run npx with the n8n-mcp package, in stdio mode, with logging at the minimum. The three environment variables you see below exist for a reason: the server must not write anything to the terminal, because anything it writes there breaks the communication channel with the client.
Claude Code
In Claude Code, the configuration lives in a JSON file named .mcp.json, inside the project folder. Its content is this:
{
"mcpServers": {
"n8n-mcp": {
"command": "npx",
"args": ["-y", "n8n-mcp"],
"env": {
"MCP_MODE": "stdio",
"LOG_LEVEL": "error",
"DISABLE_CONSOLE_OUTPUT": "true"
}
}
}
}
Then open Claude Code in the project folder. It will see the configuration and connect the server. From there you can ask it for a flow in English.
Codex CLI
In Codex CLI, the configuration is not JSON. It is written in a TOML file named config.toml, inside the .codex folder of your profile. The configuration is this:
[mcp_servers.n8n-mcp]
command = "npx"
args = ["-y", "n8n-mcp"][mcp_servers.n8n-mcp.env]
MCP_MODE = "stdio"
LOG_LEVEL = "error"
DISABLE_CONSOLE_OUTPUT = "true"
The command inside is exactly the same. Only the file shape changes, because Codex reads TOML.
Cursor
In Cursor, the configuration goes into a file named mcp.json, inside the .cursor folder of the project:
{
"mcpServers": {
"n8n-mcp": {
"command": "npx",
"args": ["-y", "n8n-mcp"],
"env": {
"MCP_MODE": "stdio",
"LOG_LEVEL": "error",
"DISABLE_CONSOLE_OUTPUT": "true"
}
}
}
}
Same shape as Claude Code, same command. Open Cursor and the server appears connected.
One honest note about the three above. We tested the server itself, through stdio, and saw that it answers correctly. We did not run all three clients from start to finish. The file locations are the established ones for each program. If something does not work for you, start there.
Where it wins, where it loses
It wins at the most practical point. The assistant no longer guesses node names. It searches an index built from n8n itself, finds the node, reads its fields, and suggests a flow with the right parts.
It also wins on checking. It does not just say “okay” to whatever you give it. When I deliberately gave it a wrong flow, it did not pass it. It caught it and explained what was missing. In other words, it corrects instead of rubber-stamping.
It also wins on its health. The repository at github.com/czlonkowski/n8n-mcp has 23,055 stars and 3,662 forks, with the latest update today, 13 October 2026. It is active, not archived. On npm it has 379,637 downloads over the last month.
Now the three points that hurt, and I will say them without circling around them.
First, telemetry is on by default. I read the PRIVACY.md file in the repository. The server sends flow structures after cleaning them, the free text of your requests, which tool was called, and how long it took — and it uses them, according to its own text, for “datasets and machine learning models for workflow generation.” The installation identifier is not random. It is generated from machine traits such as the computer name, operating system, architecture, and your folder path. In other words, it is pseudonymous, not anonymous: if someone combines those pieces, they get to you. It turns off with one command, and you should run that command.
Second, the full power needs your own n8n. The seven tools I counted know the nodes and check flows. The rest of the collection — twenty-one tools in total, which build, repair, and publish flows inside your n8n — wants an address in a variable named N8N_API_URL and a key in a variable named N8N_API_KEY. We did not run that part, so take it as what awaits you, not as our own measurement. Without that, you stay on the knowledge side, which is useful but half the story.
Third, it needs Node, and the first time it needs an internet connection to build the node database. Without those, it does not start at all.
Test
It really ran, on this machine, Windows 11, with Node 26.7, and with no n8n installed anywhere.
I started the server through stdio with “npx -y n8n-mcp”, with MCP_MODE=stdio, LOG_LEVEL=error, and DISABLE_CONSOLE_OUTPUT=true. On the first message, the initialize call, it replied that it is n8n-documentation-mcp, version 2.92.1, with protocol 2025-03-26. On tools/list it returned the seven tools I wrote above. First run: about a minute, spent building the node database.
Then I asked for a node with the word “slack” through the search_nodes tool. It returned n8n-nodes-base.slack with its variants. In other words, it found the real node, not a name that merely looks right.
The test that matters is the third one. I gave validate_workflow a deliberately wrong flow: a single node, of type n8n-nodes-base.start. The answer was valid: false, with errorCount 2, and two specific errors. The first: “Single-node workflows are only valid for webhook endpoints. Add at least one more connected node to create a functional workflow.” The second: “Unknown node type: “n8n-nodes-base.start”. No similar nodes found. Node types must include the package prefix…”. In other words, it does not just say yes. It corrects.
What was not covered. I did not set up n8n, so I did not touch the twenty-one tools that need an API key. I did not connect the server inside the three clients all the way through. What I write about the steps per client comes from the configuration the tool declares, not from our own path through the menus.
Verdict
n8n-mcp does something that was missing. It takes the knowledge of an entire automation program and puts it in your assistant’s hands, without asking it for anything at the start. No n8n, no account, no key.
And its strongest point is not that it finds nodes. It is that it checks the flow and says no. An assistant that approves everything is useless, because you never know when it is wrong. This one shows you the mistake in its own words.
The objections are serious. Telemetry on by default sends the text of your requests to an unknown recipient, and the installation identifier is not anonymous. It turns off easily, but only if you know it exists. And the best side of the tool wants your own n8n with an API key.
None of that touches the core. If you build workflows, or if you want to stop building them by hand, this is the tool. Turn off telemetry first, and start.
Score: 8.7/10.
See also
If this helped you, see also:
- gws: all Google services with one command, from the command window
- worktrunk: two jobs at the same time, without one stepping on the other
- lefthook: the checks you forget become automatic, and run in parallel
Sources:
https://github.com/czlonkowski/n8n-mcp
https://www.npmjs.com/package/n8n-mcp
Εγκατάσταση
2 ΒΗΜΑΤΑ- npx -y n8n-mcp
- npx n8n-mcp telemetry disable