n8n vulnerabilities: advisories, settings and a register for your workflows
What n8n Cloud and self-hosted n8n each leave to you, the settings that decide who can start a workflow and what it can reach, a dated log of n8n security advisories, and a register to fill in one workflow at a time.
In this guide
n8n workflow register, advisory log and webhook fixtures
Part A is a register to copy once per workflow: trigger and webhook authentication, data in and out, saved execution data, expressions, high-privilege nodes, credentials and outbound requests, each row with where to look, whether it applies to n8n Cloud, self-hosted or both, and what to record. Part B covers the instance, including queue mode.
How to use itHide the instructions
Part C logs ten n8n security advisories as of 14 November 2026, and Part D is a set of local webhook fixtures with their captured output. The checks in Parts A and B read settings, lists and reports; none records a secret, and Part D sends requests only to 127.0.0.1 or localhost.
n8n.txt
Introduction12 lines
Part A: Workflow register94 lines
Part B: Instance sheet64 lines
Part C: Advisory log109 lines
Part D: Webhook fixtures385 lines
Whole template688 lines
HOW TO USE THIS REGISTER
Copy Part A once for each published workflow that a caller outside n8n can start, and for any workflow that holds a credential to a system you care about. Fill Part B once for the instance. Read each value from the place named under "Where to look" and write it under "Record". Every check reads a setting or a list. None changes a setting, reveals a secret or sends a request to a production webhook.
Never copy a credential's value, token, password or key into the register. Record the credential's type, what it can reach and who can use it.
"Applies to" says where n8n's documentation places the setting: n8n Cloud, self-hosted n8n, or both, where "both" means the cited page is not limited to one of them or lists plans for each. "Source" names the n8n page or advisory each row relies on. The settings were read from n8n's documentation on 14 November 2026. n8n's v2.0 breaking changes page records several defaults that changed in 2.0, so check the source page for your version before relying on a default.
What is here:
Part A Workflow register: one block per workflow, rows A1 to A8.
Part B Instance sheet: rows B1 to B5, including queue mode for self-hosted instances.
Part C Advisory log: ten n8n security advisories, each tied to a register row, as read on 14 November 2026.
Part D Webhook fixtures: a local sender and an invented receiver on 127.0.0.1, with their captured output. An illustration, not n8n.
================================================================
PART A: WORKFLOW REGISTER
================================================================
WORKFLOW HEADER (one per workflow)
Workflow name: ____________________ Workflow ID: ____________
Project: ____________ Owner: ____________
Published: yes / no Date checked: ____________
Who can edit this workflow (names and roles): ______________________________
Who can view its executions (names and roles): _____________________________
A1. TRIGGER AND WEBHOOK AUTHENTICATION
Check: What starts the workflow, and what a caller must present.
Where to look: The trigger node's panel. For a Webhook node: the Authentication parameter, the Path field, and the options under Add Option.
Applies to: Both.
Source: n8n, Webhook node; n8n, Webhook credentials.
Record: Trigger node type.
Authentication: Basic auth / Header auth / JWT auth / n8n User Auth (OAuth2) / None.
If n8n User Auth (OAuth2): whether Require Workflow Execute Permission is on. n8n's page says it is on by default.
Path: generated or chosen, and any route parameters.
IP(s) Allowlist: the addresses listed, or blank. n8n's page says a blank list lets every address call the URL.
Allowed Origins (CORS): the value. n8n's page gives * as the default.
Ignore Bots: on or off.
Only Run If: the expression, if any. n8n's page says the request is let through if the expression fails to evaluate.
Note: A generated path is an address, not a credential (this page's advice). See C1.
A2. APP TRIGGERS THAT REGISTER A WEBHOOK WITH ANOTHER SERVICE
Check: Which connected service the trigger registered a webhook with, and with whose credential.
Where to look: The trigger node's panel and its credential's Sharing tab. The list of webhooks in the connected service's own settings.
Applies to: Both.
Source: n8n, advisory GHSA-h59h-rf6m-7jp5, which says that when a workflow was activated, n8n registered its trigger nodes with the connected services using the credentials set on those nodes; n8n, advisory GHSA-5m98-cgcr-xx3q.
Record: Service. Credential name and owner.
Each webhook the service lists for your n8n URL, and whether it is expected.
GitHub Trigger only: whether the workflow's static data holds a webhookSecret beside its webhookId, the check that C2's workarounds describe. Record only whether it is present, never its value.
A3. DATA IN AND DATA OUT
Check: What the workflow receives, and what a caller gets back.
Where to look: Webhook node: Respond and Response Data. A Respond to Webhook node, if used: Respond With and its options.
Applies to: Both.
Source: n8n, Webhook node; n8n, Respond to Webhook node; n8n, Redact execution data.
Record: Fields the caller sends, marking personal, health or financial data.
Respond: Immediately / When Last Node Finishes / Using 'Respond to Webhook' Node / Streaming response.
Response Data: All Entries / First Entry JSON / First Entry Binary / No Response Body.
Respond With, if a Respond to Webhook node is used.
Fields the response can carry that the caller did not send. Read them from the nodes that run before the response. Part D shows the same check made against a local copy.
Note: n8n's pages say All Entries returns all the entries of the last node in an array, that the Respond to Webhook node's Text option sends HTML by default, and that a webhook response is the raw data, not a redacted version, even where redaction is on. See C3.
A4. SAVED EXECUTION DATA AND WHO CAN READ IT
Check: Which executions n8n keeps for this workflow, and who can open them.
Where to look: Workflow menu > Settings. The project's members and their roles.
Applies to: Both. Redaction is on the last-listed plan, on n8n Cloud and self-hosted, per workflow from n8n 2.16.0.
Source: n8n, Configure workflow settings; n8n, Redact execution data; n8n, See available roles.
Record: Save failed production executions: value.
Save successful production executions: value.
The setting for executions of workflows started in the editor: value.
Save execution progress: value.
Redact production execution data, and its partner setting for executions started in the editor, where your plan has them: values.
Error Workflow (to notify when this one errors): which workflow, and what it receives.
Everyone who can view the executions. n8n's page calls a Project Viewer effectively a read-only role with access to all workflows, credentials and executions in the project, and lists that role on the last-listed plan only.
Note: See C4: on affected versions, secrets from three nodes' credentials appeared in execution error data.
A5. EXPRESSIONS THAT CARRY INCOMING DATA
Check: Which parameters build a value from what a caller sent, and where that value goes.
Where to look: Each node's parameters that hold an expression. On a self-hosted instance, the database report of n8n's security audit.
Applies to: Both for the workflow. The audit is described in n8n's documentation for self-hosted instances.
Source: n8n, Code in n8n; n8n, Expression engine; n8n, Run security audits.
Record: Node, parameter, the incoming field it uses, and the destination: a SQL query, a database filter, a shell command, a URL, an email or another system.
The audit's findings for expressions in Execute Query and Query Parameters fields of SQL nodes.
Note: See C5 and C6.
A6. HIGH-PRIVILEGE NODES
Check: Whether the workflow holds a node that can run code or commands, touch the file system or reach the network.
Where to look: The workflow canvas. On a self-hosted instance, the nodes report of n8n's security audit.
Applies to: Code and HTTP Request nodes: both. Execute Command: self-hosted only. n8n's page lists it as unavailable on n8n Cloud and disabled by default from n8n 2.0.
Source: n8n, Code in n8n; n8n, Code node; n8n, Run security audits; n8n's audit source code (OFFICIAL_RISKY_NODE_TYPES); n8n, Execute Command node; n8n, Block specific nodes; n8n, advisory GHSA-9p7v-45m2-wxgj.
Record: Each node whose type was in the audit's list on 14 November 2026: executeCommand, code, function, functionItem, httpRequest, ssh, ftp.
Read/Write Files from Disk, Git, LangChain Code, and any community or custom node.
For each: what it can reach (the host, files, the network, other systems) and who can edit the workflow.
Any Function, Function Item or LangChain Code node still in a saved workflow. See C7.
A7. CREDENTIALS
Check: Each credential the workflow uses: what it reaches, and who can use it.
Where to look: The credential's type and its Sharing tab. The account, key or app's own settings in the connected service, for its scope or role.
Applies to: Both. Credential sharing is on all n8n Cloud plans and, for self-hosted n8n, on the Business plan and the last-listed plan.
Source: n8n, Share credentials securely; n8n, Understand instance roles; n8n, advisory GHSA-h59h-rf6m-7jp5.
Record: Credential name and type.
The system it reaches, and the scope, role or permissions it holds there.
Owner. Shared with: users and projects, from the Sharing tab.
Other workflows that use it.
Whether a trigger node in a published workflow uses a credential owned by someone else. See C9.
Never record: The credential's value, token, password, key or client secret.
A8. OUTBOUND REQUESTS
Check: Which nodes send a request to an address built from incoming data.
Where to look: HTTP Request nodes, and any node whose URL or host field holds an expression.
Applies to: Both for the workflow. SSRF protection is a self-hosted setting, available from n8n 2.12.0 (row B3).
Source: n8n, Code in n8n; n8n, Enable SSRF protection.
Record: Node, field, where its value comes from, and whether the destination is fixed or chosen by the caller.
================================================================
PART B: INSTANCE SHEET
================================================================
INSTANCE HEADER
Instance: n8n Cloud / self-hosted Version: ____________ Date checked: ____________
B1. VERSION AND UPDATES
Check: Which n8n version runs, and how it is updated.
Where to look: n8n Cloud: Cloud console > Instance settings > Updates. Self-hosted: the running version and the image or package tag it is pinned to.
Applies to: Each as named.
Source: n8n, Update your version (Cloud); n8n, v2.0 Breaking changes (pinning); n8n, Run security audits (outdated instance).
Record: Cloud: n8n version, release track (Beta or Stable), update cadence and maintenance window. n8n's page says only instance owners can change these.
Self-hosted: version, how it is pinned (n8n's v2.0 page recommends pinning to a specific version number), and the audit's outdated-instance result.
Both: each Part C row whose affected ranges include your version.
Note: n8n's page says it upgrades every Cloud instance at least every two weeks.
B2. USERS, ROLES AND PROJECTS
Check: Who holds instance-wide power.
Where to look: The users list, and each project's members.
Applies to: Both. The Admin role is not on every plan; n8n's page lists where it is available.
Source: n8n, Understand instance roles; n8n, See available roles.
Record: Each Owner and Admin. n8n's page says both can view and share all workflows, and view, edit and share all credentials.
Whether the owner works day to day from a second account with the Member role, which n8n recommends.
Members who can create or modify workflows, by project.
Note: Six of the ten records in Part C start from someone already signed in to n8n.
B3. NODE, CODE AND REQUEST SETTINGS (SELF-HOSTED)
Check: The environment variables that limit what workflows can do.
Where to look: The instance's environment or configuration. Record the value set, or "not set". For a value that is a secret, record only whether it is set.
Applies to: Self-hosted.
Record:
NODES_EXCLUDE: the nodes it blocks. n8n's page says some nodes, like Execute Command, are blocked by default. Source: Block specific nodes.
N8N_BLOCK_ENV_ACCESS_IN_NODE: n8n's v2.0 Breaking changes page says the default is now true; its Security environment variables table lists false. Record what is set. Sources: both pages.
N8N_EXPRESSION_ENGINE: vm is the default from n8n 2.35.0, and earlier versions default to legacy, which runs expressions without isolation. Source: Expression engine.
N8N_EXPRESSION_ENGINE_FRONTEND: the editor's engine, available from n8n 2.41.0. It defaults to legacy, and n8n strongly recommends quickjs. Source: Expression engine.
NODE_FUNCTION_ALLOW_BUILTIN and NODE_FUNCTION_ALLOW_EXTERNAL: the modules the Code node may import. With task runners, these are set on the runners. Source: Enable modules in Code node.
N8N_RUNNERS_MODE: internal (the default, deprecated) or external. Source: Task runners environment variables; Harden task runners.
N8N_RUNNERS_INSECURE_MODE: n8n says it disables all security measures in the task runner and discourages it for production use. Source: Task runners environment variables.
N8N_RESTRICT_FILE_ACCESS_TO: from n8n 2.0, the ReadWriteFile and ReadBinaryFiles nodes can only reach ~/.n8n-files by default. Source: v2.0 Breaking changes.
N8N_SSRF_PROTECTION_ENABLED: available from n8n 2.12.0. Source: Enable SSRF protection.
N8N_PUBLIC_API_DISABLED: n8n recommends disabling the public API if you don't plan to use it. Source: Disable the public API.
N8N_COMMUNITY_PACKAGES_ENABLED, and the community packages installed. Source: C10's workarounds.
N8N_DEPRECATED_NODES_BLOCK: C7's record says setting it to false restores the vulnerable behaviour. Source: C7.
Then: Run n8n audit and keep its risk reports with this sheet. Source: Run security audits.
B4. EXECUTION DATA RETENTION AND LOGS
Check: How long execution data stays, and whether access to it is logged.
Where to look: Self-hosted: the EXECUTIONS_DATA_ variables. Both: Settings > Policies for redaction enforcement and Settings > Log Streaming, where your plan has them.
Applies to: Pruning variables: self-hosted. Redaction enforcement and log streaming: the last-listed plan, on n8n Cloud and self-hosted.
Source: n8n, Manage execution data; n8n, Redact execution data; n8n, Stream logs to external systems.
Record: EXECUTIONS_DATA_SAVE_ON_ERROR, EXECUTIONS_DATA_SAVE_ON_SUCCESS and EXECUTIONS_DATA_SAVE_ON_PROGRESS: values.
EXECUTIONS_DATA_MAX_AGE (n8n's default is 336 hours) and EXECUTIONS_DATA_PRUNE_MAX_COUNT (default 10,000). n8n's page says annotated executions are never pruned.
Redaction enforcement scope, if any (from n8n 2.26.0).
Log streaming destinations, and whether the audit events for failed logins, credential sharing and workflow activation are selected.
B5. QUEUE MODE (SELF-HOSTED)
Check: Who can reach the queue, and which machines hold the key that decrypts credentials.
Where to look: EXECUTIONS_MODE on the main instance and workers. The Redis settings. Your firewall rules, security groups or network policies.
Applies to: Self-hosted, when EXECUTIONS_MODE is queue. Otherwise skip B5.
Source: n8n, Enable queue mode; n8n, Set a custom encryption key; n8n, advisory GHSA-fmmv-p585-7c8x.
Record: Redis host and port (QUEUE_BULL_REDIS_HOST, QUEUE_BULL_REDIS_PORT). n8n's page says that by default Redis runs on localhost on port 6379 with no password.
Whether QUEUE_BULL_REDIS_PASSWORD is set: yes or no, never the value.
Every machine and network that can reach Redis.
If another deployment shares this Redis: its N8N_REDIS_KEY_PREFIX. The multi-main section of n8n's page says each deployment sharing one Redis sets a different prefix, and that before n8n 2.3.0 the prefix doesn't apply to pub/sub channels, so each deployment uses a separate Redis.
Every machine that holds N8N_ENCRYPTION_KEY: the main instance, each worker and each webhook processor. Machine names only, never the key.
Whether worker endpoints (health checks, /metrics, the credentials overwrite endpoint) can be reached from outside your private network.
Whether Execute Command is enabled. In queue mode it runs on the worker that executes the production run.
================================================================
PART C: ADVISORY LOG
================================================================
As of 14 November 2026. Ten advisories from the Security Advisories area of the n8n repository on GitHub, each tied to a register row. This is a working subset, not every n8n advisory: it leaves out others, including ones for individual integration and app nodes. For anything newer, open github.com/n8n-io/n8n/security/advisories.
How to read a row:
- Affected and Patched are copied from each record's version fields, not from its description. The n8n records in this log write each affected range as below a version (< 2.42.1) and each fix as that version or later (>= 2.42.1). Where the GitHub Advisory Database has a reviewed entry, its ranges are given too, because it gives a starting version for some of them.
- Find the patched release on the release line you run. If your line is not named, the record does not answer the question for you: write it down as unanswered and read the release notes for your line.
- "Record says" quotes the record's impact text. Severity ratings are left out; read them on the record.
- Every record in this log says its workarounds do not fully remediate the risk and should only be used as short-term mitigation measures.
- Your result: affected, not affected or not applicable, plus the version you checked and why.
C1. GHSA-4c7j-qff5-r9cx (no known CVE) Register row: A1
Title: Unauthenticated Cross-Project Workflow Execution via Webhook Path-Only Resolution
Published: 30 September 2026
Affected: < 1.123.83, < 2.42.1, < 2.41.4
Patched: >= 1.123.83, >= 2.42.1, >= 2.41.4
Record says: "A dynamic-path webhook URL contains a server-generated identifier that is the only unguessable part of it. Webhook resolution matched on the path alone and ran first, so a request omitting that identifier still resolved to the workflow and executed it. An unauthenticated caller can run a workflow in a project they have no relationship with, under that project's credentials. The same resolver serves the form and MCP routes. Node-level authentication still applies."
Workarounds: Restrict instance access to fully trusted users; enable node-level webhook authentication (Basic, Header, or JWT) on all active Webhook nodes that use dynamic path templates; deactivate workflows using dynamic-path webhooks until patched; apply network-level controls that restrict access to the /webhook/*, /form/* and /mcp/* routes to trusted sources only.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-4c7j-qff5-r9cx, read 14 November 2026.
Your result: ____________
C2. GHSA-5m98-cgcr-xx3q, CVE-2026-86080 Register row: A2
Title: GitHub Trigger 422 Reuse Path Skips Webhook Secret Storage, Causing Signature Verification to Fail-Open
Published: 2 September 2026
Affected: n8n record: < 1.123.76, < 2.38.2, < 2.37.7. GitHub Advisory Database: < 1.123.76; >= 2.38.0, < 2.38.2; >= 2.0.0, < 2.37.7.
Patched: n8n record: >= 1.123.76, >= 2.38.2, >= 2.37.7. GitHub Advisory Database: 1.123.76, 2.38.2, 2.37.7.
Record says: "The GitHub Trigger generated a signing secret when it registered a webhook and verified X-Hub-Signature-256 on each delivery. When GitHub answered the create request with a 422 because a webhook for the URL already existed, the node adopted the remote hook but kept only its id and events, discarding the secret it had generated. Deliveries to that workflow's webhook URL were then accepted from anyone."
Workarounds: Include auditing GitHub Trigger workflow static data for entries that contain a webhookId but no webhookSecret, and restricting network access to the n8n webhook endpoint to GitHub's published IP ranges.
Sources: github.com/n8n-io/n8n/security/advisories/GHSA-5m98-cgcr-xx3q and github.com/advisories/GHSA-5m98-cgcr-xx3q, both read 14 November 2026.
Your result: ____________
C3. GHSA-mp7q-23hg-35cf (no known CVE) Register row: A3
Title: Webhook Responses Without the Sandbox Policy Allow Stored Cross-Site Scripting
Published: 14 October 2026
Affected: < 1.123.85, < 2.44.1, < 2.43.5
Patched: >= 1.123.85, >= 2.44.1, >= 2.43.5
Record says: "n8n adds a sandbox Content-Security-Policy to webhook responses so that HTML from a workflow cannot run on the n8n origin. Some response paths, such as error responses and some responses without headers, did not add this policy. A member who can create and activate workflows can serve HTML that runs as a page on the n8n origin. When another user opens the webhook URL, the script can act with that user's session."
Workarounds: Include auditing active webhook workflows and reviewing the response bodies returned by nodes operating in legacy response mode for unexpected HTML or script content.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-mp7q-23hg-35cf, read 14 November 2026.
Your result: ____________
C4. GHSA-qmvv-q3c9-wpp7 (no known CVE) Register row: A4
Title: Credential Secrets Exposed in Execution Error Data of Several Nodes
Published: 14 October 2026
Affected: < 1.123.85, < 2.44.1, < 2.43.5
Patched: >= 1.123.85, >= 2.44.1, >= 2.43.5
Record says: "When an operation failed, the Git, MongoDB Atlas Vector Store, and Google Cloud Storage nodes stored an error that contained a secret from their credential: a Git password or token, a MongoDB database password, or a Google access token. A user who can view the workflow's executions, but cannot read the credential, could recover the secret from the execution data."
Workarounds: Restrict instance access to fully trusted users; limit execution read access to the minimum set of users who require it.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-qmvv-q3c9-wpp7, read 14 November 2026.
Your result: ____________
C5. GHSA-gx3v-3x3v-f8r5 (no known CVE) Register row: A5
Title: Insufficient Isolation in Workflow Expression Evaluation
Published: 28 October 2026
Affected: < 1.123.89, < 2.46.1, < 2.45.5, < 3.0.1
Patched: >= 1.123.89, >= 2.46.1, >= 2.45.5, >= 3.0.1
Record says: "An authenticated user with permission to create or modify workflows could escape the isolation applied to workflow expression evaluation and execute arbitrary code on the n8n host."
Workarounds: Include removing global:member access from any users who are not fully trusted until the instance is patched, and auditing active workflows for expressions that reference unexpected JavaScript properties.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-gx3v-3x3v-f8r5, read 14 November 2026.
Your result: ____________
C6. GHSA-6xcw-7xm6-48c6, CVE-2026-86083 Register rows: A5, B3
Title: Expression Sandbox Escape via Shared Builtin Tampering and Code-Printer Injection Leads to Code Execution
Published: 2 September 2026
Affected: n8n record: < 1.123.76, < 2.38.2, < 2.37.7. GitHub Advisory Database: < 1.123.76; >= 2.38.0, < 2.38.2; >= 2.0.0, < 2.37.7.
Patched: n8n record: >= 1.123.76, >= 2.38.2, >= 2.37.7. GitHub Advisory Database: 1.123.76, 2.38.2, 2.37.7.
Record says: "An expression that replaced that global therefore changed the code that was subsequently generated and executed, turning literal data into executable source." (The global is JSON.stringify.) "This vulnerability only affects instances running the legacy expression engine. The vm expression engine, which is the default on the patched releases, is not affected."
Workarounds: Include setting N8N_EXPRESSION_ENGINE=vm and running the n8n process under a dedicated low-privilege OS user account.
Sources: github.com/n8n-io/n8n/security/advisories/GHSA-6xcw-7xm6-48c6 and github.com/advisories/GHSA-6xcw-7xm6-48c6, both read 14 November 2026.
Your result: ____________
C7. GHSA-9p7v-45m2-wxgj (no known CVE) Register rows: A6, B3
Title: Deprecated Code Nodes Allow Code Execution in the n8n Main Process
Published: 28 October 2026
Affected: < 2.43.3, < 2.42.6, < 3.0.1
Patched: >= 2.43.3, >= 2.42.6, >= 3.0.1. The record's patch text names 2.42.6, 2.43.3, 2.44.0 and 3.0.1 as the versions in which these nodes are deprecated and blocked by default.
Record says: "The Function and Function Item nodes run user code in the vm2 sandbox, and the LangChain Code node runs user code in the n8n main process. An authenticated user with permission to create or modify workflows could use these nodes to execute arbitrary code in the n8n main process, outside the task runner isolation that applies to the Code node."
Patch note: In those versions, saving a workflow that adds or modifies one of these nodes is rejected, and workflows already saved with them continue to run unchanged.
Workarounds: Include adding n8n-nodes-base.function, n8n-nodes-base.functionItem and @n8n/n8n-nodes-langchain.code to NODES_EXCLUDE.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-9p7v-45m2-wxgj, read 14 November 2026.
Your result: ____________
C8. GHSA-m3hg-p5r9-fg9h (no known CVE) Register rows: A6, B3
Title: JavaScript Task Runner VM Sandbox Escape via EventEmitter Prototype Pollution Leads to Remote Code Execution
Published: 5 August 2026
Affected: < 1.123.69, < 2.34.1, < 2.33.4
Patched: >= 1.123.69, >= 2.34.1, >= 2.33.4
Record says: "The JS task runner's prototype-freezing routine covered globalThis functions but not internal module constructors such as EventEmitter. An authenticated user with Code node access could exploit this gap to execute arbitrary commands within the runner container." It adds: "On v1.x instances that have not enabled task runners, Code node JavaScript executes directly in the main n8n process instead" (the record's sentence goes on).
Workarounds: Include disabling Code node access for untrusted users, and running the JavaScript task runner in an isolated process per user or project where the deployment supports it.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-m3hg-p5r9-fg9h, read 14 November 2026.
Your result: ____________
C9. GHSA-h59h-rf6m-7jp5 (no known CVE) Register rows: A2, A7
Title: Workflow Activation Allows Trigger Nodes to Use Credentials the Publisher Cannot Access
Published: 13 November 2026
Affected: < 1.123.96, < 3.2.2, < 2.48.3, < 2.47.6
Patched: >= 1.123.96, >= 3.2.2, >= 2.48.3, >= 2.47.6
Record says: "When a workflow was activated, n8n registered its trigger nodes with the connected services using the credentials set on those nodes. Activation did not check that the user publishing the workflow had access to those credentials. A member who knew the ID of another user's credential could activate a workflow whose trigger used it. n8n then created or deleted webhooks on the connected service with that credential's privileges, and delivered events from resources the member chose to the member's workflow."
Workarounds: Include auditing active workflows for trigger nodes that use credentials owned by another user, and reviewing the webhooks registered on connected services such as GitLab and GitHub.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-h59h-rf6m-7jp5, read 14 November 2026.
Your result: ____________
C10. GHSA-fmmv-p585-7c8x (no known CVE) Register row: B5
Title: Community Package Install Validation Bypass via PubSub in Queue Mode Deployments
Published: 16 September 2026
Affected: < 1.123.80, < 2.40.1, < 2.39.6
Patched: >= 1.123.80, >= 2.40.1, >= 2.39.6
Record says: In deployments using Redis for scaling (queue mode), the internal handler that installs a community package applied none of the checks the normal install path performs, which the record names as name and prefix validation, the install-permission check, checksum verification and the npm safety check. It goes on: "Anyone able to write to that Redis instance could have n8n download, install and load any npm package on every instance in the cluster, with no n8n account, while that action is otherwise restricted to the instance owner."
Workarounds: Include restricting access to the Redis instance to only trusted n8n components using authentication and network-level controls, disabling community package installation with N8N_COMMUNITY_PACKAGES_ENABLED=false if community nodes are not required, and auditing installed community packages.
Source: github.com/n8n-io/n8n/security/advisories/GHSA-fmmv-p585-7c8x, read 14 November 2026.
Your result: ____________
================================================================
PART D: WEBHOOK FIXTURES
================================================================
ILLUSTRATION ONLY. The receiver below is invented for this page. It is not n8n, it does not copy n8n's code, and its status codes and messages are its own. The order, the names, the example.com addresses, the token and the signing secret are made up and unlock nothing.
What it is: four files that, apart from each other, import only node:http and node:crypto, and install no packages. The receiver asks for port 0 on 127.0.0.1, so the operating system picks the port, and keeps everything in memory. It stands in for four webhook-triggered workflows:
/webhook/open no check at all, like a Webhook node with Authentication set to None
/webhook/header needs a shared token in a header
/webhook/signed needs an HMAC-SHA256 signature of the body, like an app that signs its deliveries
/webhook/header-all-entries needs the token, then answers with every field its last step produced
The sender sends each fixture request once, one after another, and refuses any host other than 127.0.0.1 and localhost. Nothing deletes anything and nothing sends load.
Written and run on: Node.js v26.0.0, the only version it was run on. Every output below was copied from the captured files by a script.
To run it: make an empty folder, save the four files with the names shown, open a terminal in that folder and run node run-lab.mjs.
================================================================
FILE 1 OF 4: fixtures.mjs
================================================================
// fixtures.mjs: the invented values the sender and the receiver share.
// None of these is a real credential. The token and the signing secret are
// made-up strings that exist only on this computer while the lab runs.
// Never put a real token or secret in this file.
export const TOKEN_HEADER = 'x-webhook-token'
export const SIGNATURE_HEADER = 'x-signature-sha256'
export const LAB_TOKEN = 'lab-only-token-not-a-real-secret'
export const WRONG_TOKEN = 'a-guess-that-is-not-the-token'
export const LAB_SIGNING_SECRET = 'lab-only-signing-secret-not-real'
export const WRONG_SIGNING_SECRET = 'some-other-signing-secret'
// The order an invented shop sends to the webhook. The name and the
// example.com address are made up.
export const SAMPLE_ORDER = {
orderId: 'LAB-ORDER-1001',
customerName: 'Sample Customer',
customerEmail: 'customer@example.com',
items: 2,
}
================================================================
FILE 2 OF 4: receiver.mjs
================================================================
// receiver.mjs: an invented webhook receiver that stands in for four
// webhook-triggered workflows. It is not n8n and does not copy n8n's code.
// It listens on 127.0.0.1 only, on a port the operating system picks, and
// keeps everything in memory. Each accepted request "starts an execution",
// which here means one entry in the execution list and nothing else.
//
// POST /webhook/open no check at all (like choosing None)
// POST /webhook/header needs the shared token in a header
// POST /webhook/signed needs an HMAC-SHA256 signature of the body
// POST /webhook/header-all-entries needs the token, then answers with every
// field the last step produced
import http from 'node:http'
import crypto from 'node:crypto'
import {
TOKEN_HEADER,
SIGNATURE_HEADER,
LAB_TOKEN,
LAB_SIGNING_SECRET,
} from './fixtures.mjs'
const executions = []
// Fields the invented workflow adds after it looks the customer up in a CRM.
// The caller never sent them and has no reason to see them.
const FIELDS_ADDED_BY_WORKFLOW = {
crmContactId: 'LAB-CRM-5521',
assignedTo: 'sales-lead@example.com',
internalNote: 'Priority customer: call before shipping',
}
function sha256(text) {
return crypto.createHash('sha256').update(text).digest()
}
// Compares two strings without leaking where they differ. Hashing both first
// gives timingSafeEqual two buffers of the same length.
function doValuesMatch(received, expected) {
return crypto.timingSafeEqual(sha256(received), sha256(expected))
}
function signBody(rawBody, secret) {
return 'sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex')
}
function sendJson(response, status, payload) {
response.writeHead(status, { 'content-type': 'application/json' })
response.end(JSON.stringify(payload))
}
function refuse(response, status, reason) {
sendJson(response, status, { accepted: false, reason: reason })
}
function startExecution(route, order) {
const executionId = 'lab-exec-' + (executions.length + 1)
executions.push({ executionId: executionId, route: route, fieldsReceived: Object.keys(order) })
return executionId
}
function checkToken(request) {
const received = request.headers[TOKEN_HEADER]
if (received === undefined) return { status: 401, reason: 'missing ' + TOKEN_HEADER + ' header' }
if (!doValuesMatch(received, LAB_TOKEN)) return { status: 403, reason: 'token does not match' }
return undefined
}
function checkSignature(request, rawBody) {
const received = request.headers[SIGNATURE_HEADER]
if (received === undefined) return { status: 401, reason: 'missing ' + SIGNATURE_HEADER + ' header' }
if (!doValuesMatch(received, signBody(rawBody, LAB_SIGNING_SECRET))) {
return { status: 403, reason: 'signature does not match the body' }
}
return undefined
}
// Each route names the check it needs and what it sends back once accepted.
const ROUTES = {
'/webhook/open': { check: () => undefined, respondWith: 'execution id only' },
'/webhook/header': { check: (request) => checkToken(request), respondWith: 'execution id only' },
'/webhook/signed': { check: (request, rawBody) => checkSignature(request, rawBody), respondWith: 'execution id only' },
'/webhook/header-all-entries': { check: (request) => checkToken(request), respondWith: 'every field' },
}
function buildReply(route, order, executionId) {
if (route.respondWith === 'every field') {
return Object.assign({ accepted: true, executionId: executionId }, order, FIELDS_ADDED_BY_WORKFLOW)
}
return { accepted: true, executionId: executionId }
}
function handleRequest(request, response, rawBody) {
const route = ROUTES[request.url]
if (route === undefined) return refuse(response, 404, 'no such webhook')
if (request.method !== 'POST') return refuse(response, 405, 'only POST is accepted')
const problem = route.check(request, rawBody)
if (problem !== undefined) return refuse(response, problem.status, problem.reason)
const order = JSON.parse(rawBody)
const executionId = startExecution(request.url, order)
sendJson(response, 200, buildReply(route, order, executionId))
}
export function listExecutions() {
return executions.slice()
}
export function startReceiver() {
const server = http.createServer((request, response) => {
const chunks = []
request.on('data', (chunk) => chunks.push(chunk))
request.on('end', () => handleRequest(request, response, Buffer.concat(chunks).toString('utf8')))
})
return new Promise((resolve) => {
server.listen(0, '127.0.0.1', () => {
const port = server.address().port
resolve({
baseUrl: 'http://127.0.0.1:' + port,
stop: () => new Promise((done) => server.close(done)),
})
})
})
}
================================================================
FILE 3 OF 4: sender.mjs
================================================================
// sender.mjs: sends each fixture request once and reports what came back.
// It sends no load: one request per fixture, one after another. It refuses
// any address other than 127.0.0.1 or localhost, so it can only reach a
// service running on this computer.
//
// Used two ways:
// by run-lab.mjs, against the invented receiver in receiver.mjs
// on its own: node sender.mjs <webhook URL on 127.0.0.1 or localhost> <open|header|signed>
import http from 'node:http'
import crypto from 'node:crypto'
import {
TOKEN_HEADER,
SIGNATURE_HEADER,
LAB_TOKEN,
WRONG_TOKEN,
LAB_SIGNING_SECRET,
WRONG_SIGNING_SECRET,
SAMPLE_ORDER,
} from './fixtures.mjs'
const LOOPBACK_HOSTS = ['127.0.0.1', 'localhost']
const ORDER_BODY = JSON.stringify(SAMPLE_ORDER)
const CHANGED_ORDER_BODY = JSON.stringify(Object.assign({}, SAMPLE_ORDER, { items: 200 }))
function signBody(rawBody, secret) {
return 'sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex')
}
function oneHeader(name, value) {
const headers = {}
headers[name] = value
return headers
}
// Each fixture: which kind of webhook it is for, what it sends, and the
// request headers it adds. A changed body is signed before it is changed.
export const FIXTURES = [
{ kind: 'open', name: 'no credential at all', body: ORDER_BODY, headers: {} },
{ kind: 'header', name: 'no token header', body: ORDER_BODY, headers: {} },
{ kind: 'header', name: 'wrong token value', body: ORDER_BODY, headers: oneHeader(TOKEN_HEADER, WRONG_TOKEN) },
{ kind: 'header', name: 'lab token', body: ORDER_BODY, headers: oneHeader(TOKEN_HEADER, LAB_TOKEN) },
{ kind: 'signed', name: 'no signature header', body: ORDER_BODY, headers: {} },
{ kind: 'signed', name: 'signed with the wrong secret', body: ORDER_BODY, headers: oneHeader(SIGNATURE_HEADER, signBody(ORDER_BODY, WRONG_SIGNING_SECRET)) },
{ kind: 'signed', name: 'body changed after signing', body: CHANGED_ORDER_BODY, headers: oneHeader(SIGNATURE_HEADER, signBody(ORDER_BODY, LAB_SIGNING_SECRET)) },
{ kind: 'signed', name: 'signed with the lab secret', body: ORDER_BODY, headers: oneHeader(SIGNATURE_HEADER, signBody(ORDER_BODY, LAB_SIGNING_SECRET)) },
]
function assertLoopback(url) {
const hostname = new URL(url).hostname
if (!LOOPBACK_HOSTS.includes(hostname)) {
throw new Error('Refusing ' + hostname + ': the sender only talks to 127.0.0.1 or localhost.')
}
}
export function sendFixture(url, fixture) {
assertLoopback(url)
const headers = Object.assign({ 'content-type': 'application/json' }, fixture.headers)
return new Promise((resolve, reject) => {
const request = http.request(url, { method: 'POST', headers: headers }, (response) => {
const chunks = []
response.on('data', (chunk) => chunks.push(chunk))
response.on('end', () => resolve({ status: response.statusCode, body: Buffer.concat(chunks).toString('utf8') }))
})
request.on('error', reject)
request.end(fixture.body)
})
}
function readArguments() {
const url = process.argv[2]
const kind = process.argv[3]
const kinds = ['open', 'header', 'signed']
if (url === undefined || !kinds.includes(kind)) {
throw new Error('Usage: node sender.mjs <webhook URL on 127.0.0.1 or localhost> <open|header|signed>')
}
return { url: url, kind: kind }
}
async function sendFromCommandLine() {
const target = readArguments()
const fixtures = FIXTURES.filter((fixture) => fixture.kind === target.kind)
for (const fixture of fixtures) {
const result = await sendFixture(target.url, fixture)
console.log(fixture.name.padEnd(30) + ' ' + result.status + ' ' + result.body)
}
}
if (process.argv[1] && process.argv[1].endsWith('sender.mjs')) {
sendFromCommandLine().catch((error) => {
console.error(error.message)
process.exitCode = 1
})
}
================================================================
FILE 4 OF 4: run-lab.mjs
================================================================
// run-lab.mjs: starts the invented receiver, sends every fixture to it once,
// prints what came back and which requests started an execution, then stops
// the receiver. Run it with: node run-lab.mjs
import { startReceiver, listExecutions } from './receiver.mjs'
import { FIXTURES, sendFixture } from './sender.mjs'
const PATH_FOR_KIND = {
open: '/webhook/open',
header: '/webhook/header',
signed: '/webhook/signed',
}
// The response-shape check: the lab token again, sent to the webhook that
// answers with every field its last step produced.
const ALL_ENTRIES_FIXTURE = Object.assign({}, FIXTURES.find((fixture) => fixture.name === 'lab token'))
function buildPlan() {
const plan = FIXTURES.map((fixture) => ({ path: PATH_FOR_KIND[fixture.kind], fixture: fixture }))
plan.push({ path: '/webhook/header-all-entries', fixture: ALL_ENTRIES_FIXTURE })
return plan
}
function printResult(number, path, fixture, result) {
console.log(String(number).padEnd(3) + path.padEnd(29) + fixture.name.padEnd(30) + String(result.status))
console.log(' response: ' + result.body)
}
function printExecutions() {
console.log('')
console.log('Executions the receiver started:')
for (const execution of listExecutions()) {
console.log(' ' + execution.executionId.padEnd(12) + execution.route.padEnd(29) + 'fields received: ' + execution.fieldsReceived.join(', '))
}
}
async function runLab() {
console.log('Node.js ' + process.version)
const receiver = await startReceiver()
console.log('Receiver listening on 127.0.0.1, on a port the operating system picked')
console.log('')
console.log('# ' + 'Webhook'.padEnd(29) + 'Fixture'.padEnd(30) + 'Status')
const plan = buildPlan()
for (let index = 0; index < plan.length; index += 1) {
const step = plan[index]
const result = await sendFixture(receiver.baseUrl + step.path, step.fixture)
printResult(index + 1, step.path, step.fixture, result)
}
printExecutions()
await receiver.stop()
console.log('')
console.log('Receiver stopped. Requests sent: ' + plan.length + ', one each.')
}
runLab().catch((error) => {
console.error(error.message)
process.exitCode = 1
})
================================================================
RUN 1: node run-lab.mjs
================================================================
Node.js v26.0.0
Receiver listening on 127.0.0.1, on a port the operating system picked
# Webhook Fixture Status
1 /webhook/open no credential at all 200
response: {"accepted":true,"executionId":"lab-exec-1"}
2 /webhook/header no token header 401
response: {"accepted":false,"reason":"missing x-webhook-token header"}
3 /webhook/header wrong token value 403
response: {"accepted":false,"reason":"token does not match"}
4 /webhook/header lab token 200
response: {"accepted":true,"executionId":"lab-exec-2"}
5 /webhook/signed no signature header 401
response: {"accepted":false,"reason":"missing x-signature-sha256 header"}
6 /webhook/signed signed with the wrong secret 403
response: {"accepted":false,"reason":"signature does not match the body"}
7 /webhook/signed body changed after signing 403
response: {"accepted":false,"reason":"signature does not match the body"}
8 /webhook/signed signed with the lab secret 200
response: {"accepted":true,"executionId":"lab-exec-3"}
9 /webhook/header-all-entries lab token 200
response: {"accepted":true,"executionId":"lab-exec-4","orderId":"LAB-ORDER-1001","customerName":"Sample Customer","customerEmail":"customer@example.com","items":2,"crmContactId":"LAB-CRM-5521","assignedTo":"sales-lead@example.com","internalNote":"Priority customer: call before shipping"}
Executions the receiver started:
lab-exec-1 /webhook/open fields received: orderId, customerName, customerEmail, items
lab-exec-2 /webhook/header fields received: orderId, customerName, customerEmail, items
lab-exec-3 /webhook/signed fields received: orderId, customerName, customerEmail, items
lab-exec-4 /webhook/header-all-entries fields received: orderId, customerName, customerEmail, items
Receiver stopped. Requests sent: 9, one each.
(exit code 0)
================================================================
RUN 2: node sender.mjs http://203.0.113.10/webhook/orders header
================================================================
Refusing 203.0.113.10: the sender only talks to 127.0.0.1 or localhost.
(exit code 1)
Reading the output:
- Request 1: the webhook with no check started an execution for a request that carried no credential at all.
- Requests 2 to 4: no token header was refused with 401 and a wrong value with 403. Only the lab token started an execution.
- Requests 5 to 8: no signature was refused with 401, a signature made with the wrong secret with 403, and a body changed after it was signed with 403. Only the correctly signed body started an execution.
- Request 9: the same token sent to the webhook that answers with every field. The response carried crmContactId, assignedTo and internalNote, three fields the caller had not sent.
- The receiver started four executions, one for each accepted request.
- Run 2: the sender refused a non-loopback address before sending anything.
Making the same checks on an n8n instance of your own:
1. What this needs: a local test instance on 127.0.0.1 or localhost, holding a copy of the workflow whose later steps send nothing to other systems, and whose Webhook node uses a Header auth credential made from the lab's invented header name and value in fixtures.mjs, so no real secret is involved. Never point the fixtures at a production webhook: an accepted request runs the workflow it reaches.
2. Run node sender.mjs with the copy's webhook URL and the word header. Record each status code and response body. This page does not state which status codes n8n returns for a refused credential; record what your instance returns.
3. Read the copy's executions list and confirm that only the request with the lab token started an execution.
4. For the response check in row A3, take the response to the lab token request from step 2 and list every field in it that the request did not send.What n8n does, and which of your systems it touches
n8n describes itself as a low-code tool.
Trigger nodes can start its workflows, and one of them is the Webhook node, which n8n says creates webhooks that can receive data from apps and services when an event occurs. n8n's page for the node says it can also return the data generated at the end of a workflow, which makes it useful for building a workflow that processes data and returns the results, like an API endpoint.
In practice an n8n instance does two jobs at once. It answers requests from outside, through the URLs its webhooks listen on, and it holds credentials for the other systems its workflows reach: a CRM, a mailbox, a database, an accounting package. n8n's documentation names the places in a workflow where you can use code: expressions, which can use JavaScript, and the Code node, which adds JavaScript or Python.
So the review questions are the same for every workflow. Who can start it? What does it receive, and what does it hand back? What does it keep afterwards? Which credentials does it hold, and what can they reach? Who can change it?
The register on this page asks those questions one workflow at a time, and the advisory log beside it lists n8n security advisories that bear on the same areas. Zapier and Make have their own guides in this library.
n8n Cloud and self-hosted n8n: what each leaves to you
n8n's documentation gives its primary deployment options as n8n Cloud, which it calls fully managed, and self-hosted n8n on your own infrastructure.
In n8n's own comparison, hosting on Cloud is done by n8n, while self-hosting means you provide and manage the infrastructure. Maintenance is handled by n8n on Cloud and is your responsibility when you self-host.
On n8n Cloud, the Updates section of Instance settings in the Cloud console sets the n8n version, the release track, the update cadence and the maintenance window, and only instance owners can change it. n8n's page on updating says it upgrades every Cloud instance at least every two weeks, so security fixes reach everyone, whichever cadence is chosen.
Self-hosted n8n security is a longer list, because the server, the database, the environment variables and each upgrade are yours to run. n8n's own steps for self-hosted users include a reverse proxy to handle TLS, encryption at rest, running its security audit, weighing the risks of community nodes or disabling them, stopping users importing external modules in the Code node, and excluding nodes such as Execute Command or SSH.
On either option, n8n's privacy and security page on what you can do says it is also your responsibility as a customer to ensure you are securing your code and data. The workflows you build, the credentials you add, who those credentials are shared with and how each webhook is protected are settings inside your instance, and that is where this page's register looks. Where n8n's documentation places the settings this page covers:
- Plans: n8n's page on choosing how to use n8n lists one plan last in both of its plan tables, after Pro for n8n Cloud and after Business for self-hosted n8n. This page calls it the last-listed plan.
- Documented with no limit to n8n Cloud or to self-hosted n8n on the pages this guide cites: the Webhook node's authentication methods and options, and the workflow settings that decide which executions are saved. The pages for instance roles, project roles and credential sharing list plans for both. Credential sharing is on all n8n Cloud plans and, for self-hosted n8n, on the Business plan and the last-listed plan.
- On the last-listed plan only, for both Cloud and self-hosted: execution data redaction and log streaming. n8n's page for each lists where it is available.
- In n8n's documentation for self-hosted instances: environment variables such as NODES_EXCLUDE and N8N_EXPRESSION_ENGINE, SSRF protection, queue mode with Redis and workers, task runner hardening and the security audit. n8n says you can secure a self-hosted instance to protect credentials and workflow data by running a security audit, setting up SSL and SSO, restricting nodes and the public API, and redacting execution data.
- The Execute Command node is available on self-hosted n8n and, in n8n's words, isn't available on n8n Cloud.
- Code node modules: on n8n Cloud the Code node can't import external npm modules, and n8n makes the crypto Node.js module and the moment npm package available. A self-hosted instance can enable built-in and external modules with environment variables.
Testing n8n Cloud itself
n8n's security policy on GitHub asks that a suspected vulnerability be reported through its Vulnerability Disclosure Program. This page makes no statement about what n8n allows a customer to test on n8n Cloud. Read n8n's own terms and that programme before sending test traffic to an instance n8n hosts.
n8n vulnerabilities and CVEs: where they are published and how to read them
n8n publishes security advisories in the Security Advisories area of its GitHub repository, github.com/n8n-io/n8n.
Each of the ten records in this page's log names the affected and patched versions of the n8n package on npm and describes the impact, the patched releases and temporary workarounds. Some carry a CVE id; others show no known CVE.
Two of the ten in this page's log, CVE-2026-86080 and CVE-2026-86083, carry CVE ids and have reviewed entries in the GitHub Advisory Database, each linking the National Vulnerability Database record.
Read the version fields with care. The n8n records in the log list several affected ranges, each written as below a version, with a patched version for each. The GitHub Advisory Database entries give starting versions for some of those ranges, which makes those ranges narrower.
For CVE-2026-86080, n8n's record lists below 1.123.76, below 2.37.7 and below 2.38.2, and the database entry lists below 1.123.76, 2.0.0 to below 2.37.7, and 2.38.0 to below 2.38.2.
This page's advice is to find the patched release on the line you run. If your line is not named, treat the record as not answering the question, not as a clean result.
The log is a working subset as of 14 November 2026: ten advisories, each tied to a row of the register. It leaves out other published n8n advisories, including ones for individual integration and app nodes such as the MongoDB node. Before relying on it, open n8n's Security Advisories page and read anything published since that date.
Read the conditions as well as the versions. Six of the ten records describe someone already signed in to n8n: a member who can create or modify workflows, holds Code node access, can view a workflow's executions, or knows the ID of another user's credential.
Three describe someone with no n8n account: a caller of a webhook path, a sender to a GitHub Trigger's webhook URL, and anyone able to write to Redis in queue mode.
The tenth, CVE-2026-86083, describes an expression that replaced a global, and applied only to the legacy expression engine. On this evidence, who can edit workflows deserves as much attention as who can call them.
Webhook authentication: a random path is an address, not a lock
The Webhook node's Authentication parameter offers Basic auth, Header auth, JWT auth, n8n User Auth (OAuth2) and None.
Basic, Header and JWT auth use Webhook credentials. With n8n User Auth (OAuth2), only users logged in to that n8n instance can call the webhook, and the caller must send a bearer token the instance issued; a Require Workflow Execute Permission toggle appears and is on by default.
By default the Path field holds a randomly generated path, which n8n's page says is there to avoid conflicts with other webhook nodes. This page's advice is to treat that path as an address and set Authentication on every published webhook.
GHSA-4c7j-qff5-r9cx records a case in which a caller with no credentials could run a workflow: a dynamic-path webhook URL whose server-generated identifier was the only unguessable part, and webhook resolution that matched on the path alone, so a request that left the identifier out still ran the workflow, under that project's credentials.
The record adds that node-level authentication still applies, and its workarounds include node-level webhook authentication (Basic, Header or JWT) on all active Webhook nodes that use dynamic path templates.
Other node options bear on which requests a webhook acts on. IP(s) Allowlist takes a comma-separated list of addresses: a request from outside it gets a 403 error, and if it is left blank, every address can call the URL.
Allowed Origins (CORS) sets the permitted cross-origin domains, with * as the default. Only Run If runs the workflow only when an expression over the request returns true. n8n's page says it runs after the IP allowlist and authentication checks, and that if the expression fails to evaluate, n8n logs a warning and lets the request through. The register treats it as a filter and looks to Authentication for the lock.
App trigger nodes work differently. GHSA-h59h-rf6m-7jp5 says that when a workflow was activated, n8n registered its trigger nodes with the connected services using the credentials set on those nodes. CVE-2026-86080 (GHSA-5m98-cgcr-xx3q) describes the GitHub Trigger generating a signing secret when it registered a webhook and verifying X-Hub-Signature-256 on each delivery.
When GitHub answered with a 422 because a webhook for the URL already existed, the node adopted the remote hook but kept only its id and events, discarding the secret it had generated, and deliveries to that workflow's webhook URL were then accepted from anyone.
Its workarounds include auditing the workflow's static data for a webhookId with no webhookSecret, which is a row in the register.
Public execution data: what a caller gets back, and who reads it later
Execution data leaves a workflow in two directions.
The first is the response to whoever called the webhook, which the Respond setting decides. Immediately returns the response code and the message Workflow got started. When Last Node Finishes returns the data output from the last node executed, and with Response Data set to All Entries that is all the entries of the last node in an array.
Using 'Respond to Webhook' Node hands the response to that node, whose Text option sends HTML by default.
That is how a workflow that looks a customer up can hand back fields the caller never sent. The fixtures in Part D of the asset show the shape: a request carrying an order came back with the order and three fields the caller had not sent, a CRM record id, an assignee and an internal note.
Since n8n 1.103.0, n8n wraps HTML responses to webhooks in a sandboxed iframe. GHSA-mp7q-23hg-35cf records that some response paths, such as error responses and some responses without headers, did not add the sandbox policy.
It says a member who can create and activate workflows can serve HTML that runs as a page on the n8n origin, and that when another user opens the webhook URL, the script can act with that user's session.
The second direction is inward. Workflow settings decide whether n8n saves failed production executions, successful production executions, executions started in the editor, and execution progress for each node. n8n's redaction page names what redaction hides: the input and output data of workflow executions, the data payload processed by each node.
Project roles decide who can read it. n8n calls a Project Viewer effectively a read-only role with access to all workflows, credentials and executions in a project, and lists that role on the last-listed plan only.
A Project Editor, which n8n lists on n8n Cloud Pro and on the last-listed self-hosted plan, can view, create, update and delete them.
Read access to executions can include read access to secrets. GHSA-qmvv-q3c9-wpp7 records that, when an operation failed, the Git, MongoDB Atlas Vector Store and Google Cloud Storage nodes stored an error containing a secret from their credential, and that a user who could view the workflow's executions, but not read the credential, could recover the secret from the execution data. Its workarounds include limiting execution read access to the minimum set of users who require it.
Execution data redaction hides that input and output data from people viewing executions while keeping status, timing and node names visible. n8n lists it on the last-listed plan, for both n8n Cloud and self-hosted, per workflow from n8n 2.16.0 and as an instance-wide floor from 2.26.0. n8n's page is plain about its limits: a webhook response is the raw data, not a redacted version; data a Code node logs with console.log is not redacted; and redaction doesn't change execution data in the database, so anyone with direct database access can read it.
In n8n's documentation for self-hosted instances, pruning deletes finished executions on a schedule, and n8n enables it by default. n8n prunes executions that finished more than EXECUTIONS_DATA_MAX_AGE hours ago (default 336 hours, 14 days), and when the total exceeds EXECUTIONS_DATA_PRUNE_MAX_COUNT (default 10,000) it deletes executions from oldest to newest.
Annotated executions are never pruned. n8n's privacy page says self-hosted users are responsible for deleting user data, and recommends configuring n8n to prune execution data automatically every few days.
Expressions, the Code node and nodes that reach the host
Expressions are the JavaScript snippets n8n evaluates at runtime to set node parameters dynamically.
On a self-hosted instance, N8N_EXPRESSION_ENGINE chooses the engine the server uses: vm runs expressions in a sandboxed V8 isolate and is the default from n8n 2.35.0, quickjs runs them in a QuickJS sandbox, and legacy runs them without isolation. Earlier versions default to legacy. The editor has its own setting, N8N_EXPRESSION_ENGINE_FRONTEND, available from n8n 2.41.0, which defaults to legacy; n8n strongly recommends quickjs for it.
Expression sandboxes have their own advisories. GHSA-gx3v-3x3v-f8r5 says an authenticated user with permission to create or modify workflows could escape the isolation applied to workflow expression evaluation and execute arbitrary code on the n8n host. CVE-2026-86083 applied only to instances running the legacy engine, and its workarounds include setting N8N_EXPRESSION_ENGINE to vm.
Expressions also carry incoming data into other systems. n8n's security audit reports expressions used in the Execute Query and Query Parameters fields of SQL nodes. The register asks, for each workflow, which parameters take values from a webhook or form, and where those values end up: a query, a filter, a command, a URL or a message.
The Code node runs JavaScript or Python as a step in a workflow. n8n's v2.0 breaking changes page says task runners are enabled by default from 2.0 and that all Code node executions run on them.
For self-hosted instances, n8n's hardening page recommends external mode, which launches runners as separate containers, along with a distroless image, the unprivileged nobody user, a read-only root filesystem and an AppArmor profile. GHSA-m3hg-p5r9-fg9h says an authenticated user with Code node access could execute arbitrary commands within the runner container, and that on v1.x instances that have not enabled task runners, Code node JavaScript executes directly in the main n8n process instead.
Whether expressions and the Code node can read the server's environment variables is set by N8N_BLOCK_ENV_ACCESS_IN_NODE, and n8n's documentation gives two answers for its default. The v2.0 breaking changes page says the default is now true, blocking access from the Code node; the table of security environment variables lists false. The register records the value set on your instance instead of relying on either page.
n8n's security audit also reports official risky nodes, which its documentation describes as built-in nodes that can be used to fetch and run any code on the host system. On 14 November 2026 the list in the audit's source code named the node types executeCommand, code, function, functionItem, httpRequest, ssh and ftp.
The Execute Command node runs shell commands on the host machine that runs n8n, or in the n8n container under Docker, and in queue mode on the worker that executes the production run. n8n disables it by default from 2.0.
On a self-hosted instance, NODES_EXCLUDE stops n8n loading a node at all, and n8n suggests Execute Command and Read/Write Files from Disk as nodes you might start with.
GHSA-9p7v-45m2-wxgj concerns deprecated nodes. It says the Function and Function Item nodes run user code in the vm2 sandbox and the LangChain Code node runs it in the n8n main process, and that an authenticated user with permission to create or modify workflows could use these nodes to execute arbitrary code in the main process, outside the task runner isolation that applies to the Code node.
In the versions its patch text names, these nodes are deprecated and blocked by default: saving a workflow that adds or modifies one is rejected, while workflows already saved with them continue to run unchanged. The register therefore asks you to list any that remain.
Three of the four records in this section start from someone who can create or modify workflows or holds Code node access. The register therefore records who can edit each workflow, and treats edit access to a workflow that holds an Execute Command, Code or HTTP Request node as access to whatever that node can reach.
Nodes that make outbound requests raise the server-side request forgery question. From n8n 2.12.0, a self-hosted instance can set N8N_SSRF_PROTECTION_ENABLED to true, and n8n then validates outbound HTTP requests from user-controllable nodes, such as the HTTP Request node, against blocked and allowed ranges, including redirect targets. n8n describes it as an additional application-level defence and says network-level protections should always be the primary line of defence. The SSRF guide in this library covers the wider problem.
Credential scope: what each credential reaches, and who can use it
On a self-hosted instance, n8n creates a random encryption key on first launch, saves it in the ~/.n8n folder and uses it to encrypt credentials before they are saved to the database.
In queue mode the same key has to be set on every worker.
A credential can be shared with a user or with a project, and the people it is shared with get the Can use role: they can run and publish workflows with it, but can't see or edit its details. Instance owners and instance admins can view and share all credentials on an instance, and a credential's Sharing tab lists everyone with access and every project that uses it.
The register records who can use each credential, not only who owns it. GHSA-h59h-rf6m-7jp5 records that workflow activation did not check whether the user publishing a workflow had access to the credentials on its trigger nodes, so a member who knew the ID of another user's credential could have n8n create or delete webhooks on the connected service with that credential's privileges. Its workarounds include auditing active workflows for trigger nodes that use credentials owned by another user.
For each credential, the register records its type, the system it reaches and the scope or role it holds there, its owner, who and which projects it is shared with, and which workflows use it. It never records the value. The credential's type, its Sharing tab and the connected service's own settings answer the register's questions, so nothing in it asks you to open, reveal or copy a secret. If a credential's value has already been exposed, the secrets exposure guide covers revoking and rotating it.
Self-hosted n8n security in queue mode: Redis, workers and the shared key
n8n's documentation for self-hosted instances says queue mode provides the best scalability.
The main instance handles timers and webhook calls and generates each execution without running it, Redis holds the queue, and a worker picks the execution up, reads the workflow from the database, runs it and writes the results back. Optional webhook processors add a layer that handles incoming webhook requests.
n8n's queue mode page gives the facts that decide who can reach what. By default, Redis runs on localhost on port 6379 with no password, and a username and password are optional settings. The main instance's encryption key must be shared with every worker and webhook processor so they can access credentials stored in the database.
And each worker runs a server with optional endpoints: health checks when QUEUE_HEALTH_CHECK_ACTIVE is enabled, a credentials overwrite endpoint, and /metrics.
GHSA-fmmv-p585-7c8x records what write access to Redis meant in one case. In queue mode, the internal handler that installs a community package applied none of the checks the normal install path performs, so anyone able to write to that Redis instance could have n8n download, install and load any npm package on every instance in the cluster, with no n8n account.
Its first workaround is restricting access to the Redis instance to only trusted n8n components, using authentication and network-level controls.
The register's queue mode block records where Redis runs, whether it asks for a password (yes or no, never the value), which machines and networks can reach it, which machines hold the encryption key, and whether worker endpoints can be reached from outside your private network.
Where Execute Command is enabled, n8n's page for the node says that in queue mode it runs on the worker executing the task in production mode, so a worker's own access belongs in the same block.
How to use the register and the advisory log
The asset on this page has four parts.
Fill Part A once for each published workflow that a caller outside n8n can start, and for any workflow that holds a credential to a system you care about. Fill Part B once for the instance. Then compare the version in Part B with the ranges in Part C.
- Work from the screens and settings each row names. Every row reads a value, and none asks you to change a setting, reveal a secret or send a request to a production webhook.
- On a self-hosted instance, run n8n's security audit first. n8n documents running it with n8n audit from the command line, with a POST call to the public API's /audit endpoint authenticated as the instance owner, or with the n8n node. It produces risk reports on credentials, database, file system, nodes and instance. The instance report covers unprotected webhooks, missing security settings and whether the instance is outdated.
- Start with workflows whose trigger has Authentication set to None, then those holding Execute Command, Code or HTTP Request nodes, then those whose credentials reach customer or financial data.
- Mark each Part C row affected, not affected or not applicable for your version, with the reason. A row whose release line is not named stays unanswered until the release notes for your line settle it.
- Use Part D only against its own invented receiver or a local test instance holding a copy of the workflow that sends nothing on to other systems. An accepted request runs the workflow it reaches.
- Fill the register again after an upgrade, a new published workflow, or a change to who can edit workflows or use credentials.
The webhook fixtures, and what running them showed
Part D is an illustration, not n8n and not a copy of n8n's code.
It is four small files: the invented values the two sides share, a receiver, a sender and a script that runs them. Apart from each other, they import only node:http and node:crypto, and they install no packages. The receiver asks for port 0 on 127.0.0.1. Node.js's net documentation says that when server.listen() is given port 0, the operating system will assign an arbitrary unused port.
It stands in for four webhook-triggered workflows: one with no check, one that needs a token in a header, one that needs an HMAC-SHA256 signature of the body, and one that needs the token and then answers with every field its last step produced.
It was written and run on Node.js v26.0.0, the only version it was run on, and every output in Part D was copied from the captured files by a script.
In the run Part D prints as RUN 1, the webhook with no check accepted a request that carried no credential and started an execution. The header webhook refused a request with no token header (401) and one with the wrong value (403), and accepted the lab token.
The signed webhook refused a missing signature (401), a signature made with the wrong secret (403) and a body changed after it was signed (403), and accepted the correctly signed body. The receiver started four executions in all, one for each accepted request.
The ninth request sent the lab token to the webhook that answers with every field, and the response carried crmContactId, assignedTo and internalNote, three fields the caller had not sent.
The receiver hashes both values with SHA-256 before comparing them with crypto.timingSafeEqual. The Node.js crypto documentation says timingSafeEqual compares the underlying bytes using a constant-time algorithm, and that an error is thrown if the two values have different byte lengths.
To make the same checks on an n8n instance of your own, you need a local test instance holding a copy of the workflow whose later steps send nothing to other systems, and whose Webhook node uses a Header auth credential made from the lab's invented header name and value in fixtures.mjs, so no real secret is involved.
Then run node sender.mjs with the copy's webhook URL and the word header. Record the status code and body of each response, and read the copy's executions list. This page does not state which status codes n8n returns for a refused credential, so record what your instance returns.
The sender refuses any host other than 127.0.0.1 and localhost, and in the run Part D prints as RUN 2 it refused a non-loopback address before sending anything.
What the register leaves open
The register is a record of settings and access.
It leaves several things open, and each needs a different kind of work.
- How a workflow behaves when an incoming field holds hostile input, such as a value an expression drops into a query or a URL. That takes testing on a copy of the workflow, not reading its settings.
- Whether an advisory was used against your instance before you upgraded. A patched version closes the flaw from the upgrade onwards and says nothing about the time before it.
- What sits outside the screens the register reads: the database itself, which n8n's redaction page says anyone with direct database access can read, server and runner logs, and the systems your workflows send data to.
- n8n Cloud's own infrastructure, and the services your credentials reach. Their owners answer for those.
- Events over time. Where log streaming is on your plan, the audit events n8n can stream include failed logins, credential sharing and workflow activation, and the security logging guide covers what to keep and what to alert on.
- If you think a workflow or credential has already been misused, call an incident response specialist first. Clever Ops does not provide emergency incident response or round-the-clock monitoring.
Where a Clever Ops test fits
This guide is for owners checking their own n8n instance.
Clever Ops tests what customers reach through a browser or an API. Where your web application or its API sends data to an n8n webhook, or acts on what a workflow returns, testing your application's side of that exchange is work for a scoped web application and API penetration test. n8n Cloud is run by another business, and the methodology keeps such services out of scope unless their owner agrees.
Where Clever Ops built or hosts your application, the work counts as a security review, not an independent test, and its report names who built the application and who hosts it. Load and denial-of-service testing is referred to a load-testing specialist and needs your host's written approval, and this guide includes no destructive workflow test.
A report is evidence for a decision, such as a customer's or an auditor's, and it is not a certificate.
Bring the filled-in register to the scoping call. It shows which workflows your application depends on, what each one receives and returns, and which credentials sit behind them, which is what a scope needs to decide what is in and what stays out.
Frequently asked questions
In the Security Advisories area of the n8n repository on GitHub, github.com/n8n-io/n8n. Each of the ten records in this page's log lists the affected and patched versions of the n8n package, the impact and temporary workarounds. Some records carry a CVE id and have a reviewed GitHub Advisory Database entry that links the National Vulnerability Database record; others show no known CVE. A search by CVE id alone can therefore miss some. The log on this page is a dated subset, not a replacement for that list.
Yes, on a schedule the instance owner can shape. n8n's page says it upgrades every Cloud instance at least every two weeks, so security fixes reach everyone whichever cadence is chosen. In the Cloud console, the instance owner picks the version, a Beta or Stable release track, the update cadence and a maintenance window, and an update to a major version, or one that runs a database migration, can't be rolled back. On self-hosted n8n, upgrades are yours, and n8n's v2.0 notes recommend pinning to a specific version number.
Set the Webhook node's Authentication to Basic auth, Header auth, JWT auth or n8n User Auth (OAuth2) rather than None, and don't rely on the generated path, which n8n creates to avoid conflicts between webhook nodes. IP(s) Allowlist can limit callers to listed addresses, and a request from anywhere else gets a 403 error. Only Run If is a filter: n8n's page says that if its expression fails to evaluate, n8n logs a warning and lets the request through.
That is your decision, made with what the node does in view. It runs shell commands on the host machine that runs n8n, n8n says it can introduce significant security risks in environments that operate with untrusted users, and it is disabled by default from n8n 2.0. It isn't available on n8n Cloud. If you enable it by removing it from NODES_EXCLUDE, this page's advice is to record who can edit workflows on that instance, and to list every workflow that uses the node in row A6 of the register.
No. Redaction hides each node's input and output data from people viewing executions, and users with the reveal scope, which instance owners and admins hold by default, can still reveal it, with the action logged. What n8n's page says it does not cover includes the raw response sent back to a webhook caller, console.log output from the Code node, authentication headers in outbound requests, and the database itself, which anyone with direct database access can read. n8n lists redaction on the last-listed plan.
It produces risk reports, one each for credentials, database, file system, nodes and instance. Credentials: credentials not used in a workflow, in an active workflow or in a recently active workflow. Database: expressions in the Execute Query and Query Parameters fields of SQL nodes. File system: nodes that interact with the file system. Nodes: official risky nodes, community nodes and custom nodes. Instance: unprotected webhooks, missing security settings and whether the instance is outdated. n8n documents running it as n8n audit from the command line, through the public API as the instance owner, or with the n8n node.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.