n8n Review July 2026: 2.26 Is Out, the MCP Server Is Real, and Pricing Moved to Euros

Two months ago the pick was simple: self-hosted n8n on a cheap VPS, because it deletes the per-execution pricing that quietly kills Zapier and Make power users. That thesis holds. What changed is the ceiling. n8n is now on 2.26.2 (per the release notes, fetched 2026-07-02), it shipped a native MCP server on April 29 that builds workflows from a prompt, and cloud pricing moved to euros. The old 4.3 review rated a 2.0-era product. This one is a 4.5, and the half-point comes almost entirely from the MCP server doing something the category has promised for a year.

Here is the short version before the details. For a solo builder who can run Docker, the Community Edition on an $11/mo Cloudways box (Cloudways pricing) is the pick. An ops team past 2,500 executions a month with nobody to own uptime can defend the 50 EUR Pro plan. A dev shop that already self-hosts should run the free Community Edition and spend the license savings on backups. Make is the pick only if nobody on your team wants to touch a container.

What actually changed since the May review

Four things, and only one is cosmetic.

The native MCP server (April 29, 2026) is the headline. You point Claude Desktop, ChatGPT, Cursor, or Windsurf at your n8n instance, describe a workflow in plain text, and n8n builds it, validates it, runs a test, and fixes its own errors before handing it back (n8n blog, fetched 2026-07-02). It is first-party and lives in every edition, including the free self-hosted Community Edition.

n8n 2.0 (December 2025, now stable at 2.26) rewrote the security baseline. Task runners are on by default, so Code node executions run in isolated environments with limited access; environment variables are blocked from Code nodes; command-execution nodes are off unless you explicitly enable them (n8n 2.0 blog, December 8, 2025). Binary data no longer sits in memory, which was the source of out-of-memory crashes on large files.

Pricing went euro-denominated. Cloud Starter is 20 EUR/mo (2,500 executions, 50 AI Workflow Builder credits) and Cloud Pro is 50 EUR/mo (10,000 executions, 150 AI credits), both billed annually (n8n pricing, as of 2026-07-02). Every paid tier now carries unlimited active workflows.

And 2.22.0 (May 2026) simplified MCP client connections. You pick a preconfigured server from the node panel, sign in, and it is wired to your agent, no manual credential setup (n8n docs). Initial coverage is Apify, Linear, monday.com, Notion, and PostHog.

What the AI Agent node actually does

Strip the marketing and the AI Agent node is a LangChain-style agent loop wired into the canvas. It takes a chat model, an optional memory node, and a set of tools, then plans and executes multi-step tasks against those tools until it reaches an answer.

The model backends are the ones you would want. It drives OpenAI, Anthropic, Google Gemini, Groq, and Mistral through their API nodes, and it runs local models through Ollama for anything you do not want leaving your box. Swapping the backend is a dropdown, not a rewrite, which matters when a provider changes pricing or deprecates a model out from under you.

Memory is a separate node you attach, and the type is a real decision. Simple Memory (the in-workflow buffer) is fine for a single session and evaporates when the run ends. For state that survives across runs you wire in Postgres Chat Memory or Redis, or a vector store like Pinecone or Qdrant when the "memory" is really retrieval over documents. Pick wrong and your agent either forgets everything between messages or drags context it should have dropped.

Tool-calling is where n8n earns its place over a bare chat wrapper. A tool is any other n8n node, a raw HTTP request, or a sub-workflow, exposed to the model with a description. The model decides when to call it; n8n handles the invocation and feeds the result back into the loop. So an inbox-triage agent reads Gmail, calls an enrichment API, and posts to Slack, all as tools the model reaches for on its own.

The candid con has not moved since the last review. The AI Agent node does not absorb LLM failure for you. Malformed model output can halt a run mid-execution, and a dependable production agent is an engineering task: you build the retry path and the fallback branch yourself. Here is the minimum shape of that, wired around the agent as an error output:

// n8n Code node on the agent's error branch:
// catch a malformed / failed agent run and degrade gracefully
const item = $input.first();
const err = item.json.error ?? {};

if (err.message?.includes('Could not parse') || err.name === 'OutputParserException') {
  // model returned junk. Route to a human instead of dying.
  return [{ json: { route: 'human_review', reason: 'agent_parse_fail', raw: err.message } }];
}

// transient provider error: signal a retry (n8n's node-level retry handles the backoff)
return [{ json: { route: 'retry', reason: err.message ?? 'unknown' } }];

Wire that into the node's error output, set the agent node's own retry-on-fail to two or three attempts, and you have the reliability layer n8n does not ship by default. The node gives you the loop. You give it the guardrails.

The MCP server: build a workflow by describing it

This is the change worth the upgrade. The MCP server has existed for a few months, but until late April it could only run existing workflows. Now it builds new ones and edits old ones, directly inside your instance (n8n blog).

What it looks like in practice, from n8n's own worked example: the author told Claude Desktop, "create an n8n workflow that once a day at 7am sends me an email with today's forecast, use my gmail account, I live in New York City." A few minutes later n8n had built the workflow, validated it, and run a test. The one thing it got wrong was leaving the Gmail address blank, which threw an error the author fixed by hand. Then he kept talking to it: "this is too code-heavy, use a template in the Gmail node instead of a code node." It rebuilt the workflow to match.

Under the hood the client does more than call a "create workflow" tool. It generates the workflow, validates it, fixes validation errors, executes a test with generated data, reads any runtime error, and repeats until it works (n8n blog). You watch it happen inside your AI client.

You enable the instance-level MCP server in n8n settings, copy the connection details, and add them to your client. It is an HTTP-transport MCP endpoint, not a local npx process. For Claude Desktop with an access token, the entry in claude_desktop_config.json is:

{
  "mcpServers": {
    "n8n-mcp": {
      "type": "http",
      "url": "https://<your-n8n-domain>/mcp-server/http",
      "headers": {
        "Authorization": "Bearer <YOUR_N8N_MCP_TOKEN>"
      }
    }
  }
}

Config shape follows the n8n MCP setup guide (fetched 2026-07-02). OAuth2 is the recommended path and skips the token; the guide also covers Claude Code, Codex CLI, and Google ADK. Restart the client and the n8n tools appear. Use n8n 2.18.4 or higher for the best workflow-building experience.

The candid cons are real. It is public preview, not GA, so treat generated workflows as drafts, not production. It fills in what it can and leaves the rest, which in the weather example was a blank email field that would have failed silently in a less obvious spot. And it is a builder, not a reviewer: it does not know your credentials are wrong or your data schema drifted. For a first draft of a workflow you would otherwise wire by hand, it is a genuine time cut. For anything customer-facing, you still read every node before you activate it.

Pricing: cloud, self-hosted, and what "unlimited workflows" changed

Cloud pricing is now in euros. The USD figures below use roughly 1 EUR = 1.08 USD (mid-2026), so read them as approximate.

Plan	Price (EUR, annual, n8n pricing)	USD approx	Executions/mo	AI Builder credits	Hosting
Cloud Starter	20 EUR/mo	~$22/mo	2,500	50	n8n cloud
Cloud Pro	50 EUR/mo	~$54/mo	10,000	150	n8n cloud
Cloud Business	667 EUR/mo	~$720/mo	40,000	coming soon	n8n or self
Community Edition	0	$0	Unlimited	n/a	You self-host

Prices and limits per n8n's pricing page, as of 2026-07-02.

The self-hosted math is the whole argument. The Community Edition is a Docker image with no license fee and no execution cap. Run it on a bare VPS from a provider like Hetzner or DigitalOcean for a few dollars a month, or run it managed. Cloudways puts a 2GB DigitalOcean box at $11/mo on monthly billing (per cloudways.com/pricing, fetched 2026-07-02), which handles server patching and backups so you are not also being a sysadmin. Run n8n on Cloudways and you get the unlimited-execution economics without owning the whole ops stack.

The line that used to bite is gone. Before April 2026, paid cloud plans capped how many workflows you could keep active at once, so a team on Starter had to deactivate one automation to enable another. That cap is dropped across all paid tiers now. You pay for executions, not for the count of live workflows, which makes Starter far more usable for a portfolio of small automations that each run occasionally.

Executions are still the wall, and they arrive early. 2,500 a month on Starter sounds generous until a single workflow polling every fifteen minutes eats 2,880 runs on its own. Pro's 10,000 covers most small teams; past that you are on Business at 667 EUR or you are self-hosting. If your volume is real and your team is technical, the cloud plans stop making sense fast. That is the entire case for the Community Edition.

Cloud vs self-hosted: the decision in three rows

Your situation	Pick	Why
No one wants to run Docker or handle uptime	n8n Cloud (Starter or Pro)	You pay 20 to 50 EUR to make ops someone else's problem. The execution cap is the tradeoff.
Comfortable with Docker, want to control cost	Community Edition on a managed VPS	$0 license, unlimited executions, ~$11/mo hosting (Cloudways pricing). You own patching and backups.
High volume, technical team, needs governance	Self-hosted (Community or Enterprise)	Executions would blow past cloud caps; self-hosting removes the meter and keeps data on your infrastructure.

The 2.0 security work shifted this table. Before, self-hosting meant accepting that Code nodes ran with broad access and large files could OOM your instance. Task runners on by default and filesystem-based binary handling remove both of those as reasons to pay for cloud isolation. The remaining reason to buy cloud is genuinely just ops: you do not want to own uptime, backups, and upgrades.

The verdict, per persona

n8n 2.26 is the automation platform we recommend in July 2026 for anyone who can run a container, and the rating moves from 4.3 to 4.5 for one reason: the MCP server turns "describe it and it builds it" from a demo into a workflow that lands in your instance and runs. The self-hosting economics were already the strongest in the category. The AI story is now the strongest too.

For a solo builder, buy the Community Edition and self-host it. If you are comfortable with Docker, a $7 to $11/mo box (Cloudways pricing) gives you unlimited executions and the full AI Agent node for zero license cost, and the MCP server means your existing Claude or Cursor subscription becomes the workflow builder. Skip cloud unless you actively dislike server maintenance.

For an ops team, the call is the Pro plan at 50 EUR/mo if you clear 2,500 executions a month and have nobody to own uptime. You are paying for someone else to keep it running, and the unlimited-active-workflows change makes a portfolio of automations viable on one plan. If you have even one engineer who can manage Docker, self-host instead and put the difference into monitoring.

For a dev shop that self-hosts, buy nothing. Run the free Community Edition, take the 2.0 secure-by-default posture as the reason you no longer need cloud's isolation, and spend the saved license fee on redundant hosting and database backups. Business-critical workflows need the reliability you are now responsible for. That is the real cost of the pricing curve, and it is worth paying.

The recommendation flips in exactly one case. If nobody on your team wants to touch a Docker container or a JSON node, Make is the better on-ramp at $9 to $16/mo (per make.com/pricing, fetched 2026-07-02) with hosting included and a gentler builder. You give up the code-node ceiling and the self-hosted economics, but you get a tool a non-technical operator can actually run. For everyone else, n8n is the pick.

Ready to start? Stand up the self-hosted Docker image from n8n first, since the pricing argument only holds on the self-hosted path, or run it managed on Cloudways if you want the economics without the ops.