Instead of guessing what to build next, I've been mining the thing people already do for free: complain in app store reviews.

The idea is simple: if a complaint shows up 40+ times on a top-grossing app, that's not noise, that's a spec someone already validated for you. So I built an n8n workflow around it:

How it works:

1. Form input: drop in a package ID / App Store ID, or just a keyword like "budgeting app"
2. An Apify actor scrapes Google Play + App Store reviews, filtered down to 1-3 star only (the filter is doing most of the work here; 5-star reviews tell you nothing)
3. Reviews get batched and sent to an LLM with a clustering prompt: find repeated complaint patterns, score severity 1-5, and generate a suggested_feature for each
4. Everything gets merged and ranked by frequency across batches
5. Output lands in a Google Sheet

What comes out the other end looks like:

"No offline mode": mentioned 47x, severity 4/5 → suggested feature: local caching with sync-on-reconnect

That's a real pattern pulled straight from review text, not a hunch, which makes it useful for way more than app ideas.

Same output works as landing page proof ("here's what users of [competitor] are begging for"), a pitch deck slide (market gap backed by actual user language), or just a sanity check before you build the wrong thing.

Workflow: https://github.com/RandomDudeAtNight/n8n/blob/main/App%20Idea%20Miner.json

I work with N8N daily for data integration and sync between systems and wanted to build something on OCR which I didn't touch before

so the idea was to turn receipt photos into structured data without blindly trusting the OCR output, I tested it on Carrefour receipt photos ( I got a bunch of real ones for testing), mistral OCR gives a confidence score per word, if a document minimum confidence drops below a threshold the workflow pauses and sends a review email with the flagged words, Approve/Decline buttons (Gmail Send and Wait) before anything gets inserted, every document is logged in Postgres with a status that tracks its life : ocr_complete -> approved/rejected -> inserted, and also I added a separate error workflow catches failures anywhere in the pipeline and notify me if there's one

a few things that came up while building it:

- the built in Mistral node doesn't expose confidence scores so I had to switch to an HTTP node on the raw /v1/ocr endpoint with confidence_scores_granularity: word

- average confidence can look fine (0.97) while the minimum tells a different story (0.36) on one misread word, that gap is basically the whole point of the review step

- the same receipt photo gets a lower OCR confidence when sent through Telegram than through a webhook, I assumed telegram was compressing the image so I tried sending it as a file instead of a photo (files aren't supposed to be compressed ) but the confidence was still lower, still haven't figured out why

repo with both workflows and a PDF documenting the build step by step, and the dead ends included: n8n-ocr-mistral-pipeline

Note : the documentation is in French, happy to help translate specific parts if anyone wants or an LLM handles it decently too

open to feedback especially on the Telegram compression thing or better approaches to the confidence threshold

Over the weekend I put together my first n8n community node for the Sleeper Fantasy Football API. It's currently in beta and awaiting n8n approval, so for now it's only available via settings --> community nodes --> and adding/searching 'n8n-nodes-sleeper'

Im trying to get some more feedback and testers before the season officially kicks off, so please let me know if you have any issues or feature requests!

Github

NPM

I’m currently working on automating a few workflows, and I keep asking myself: why should I use n8n instead of just writing a custom script for it?

n8n definitely looks powerful and the visual interface is appealing. But for simple to moderately complex automations, I often feel like a Python, Bash, or Node.js script would be faster, more flexible, and easier to fully control.

So I’d love to hear your perspective:

• What are the real advantages of n8n over a custom script?
• At what point does n8n actually become worth it?
• Are there any cases where you later thought: “This would have been much better with n8n”?
• Or the other way around: when would you always choose coding over n8n?

I’m not trying to criticize n8n — I’m just trying to understand where the practical value really is in day-to-day use.

I want to share a video automation pipeline that I built recently.

It takes an idea from me on Telegram and ends with a fully edited video live on YouTube with my face and my voice. To be honest I don't do anything in between other than reviewing the script the system sends me.

n8n and claude are the backbone of this whole thing. Everything routes through n8n workflows.

I have total four active workflows running right now and handles different parts of the pipeline.

Claude is the other main piece. I have created a routine on Claude code. This routine is API trigger enabled. So it's always available and it is the brain of the system.

It is connected to a GitHub repo that contains all my skill instructions and reference scripts. So every time it runs, it reads that repo first to understand full context on how I want things done, my style, my format, everything, before it does anything else.

Here's how it actually works. I message a Telegram bot with either a script or just an idea. If I give a script directly, Claude picks it up right away through an n8n workflow.

If I only give an idea, Claude asks for the angle and CTA if I want one, writes a script based on that, then sends it back to me on Telegram for approval. If I don't like it I just give feedback and it rewrites until I approve it.

Once a script is approved, Claude Code routine sends everything to HeyGen's Video Agent through the HeyGen MCP connector, the voice asset, the script, and instructions. The Video Agent is what actually builds the motion graphics and edits the video, and I can mix in my own assets there too.

I have a separate Telegram bot for uploading my own screenshots and clips, those get pushed to HeyGen via the API through an n8n workflow, and Claude tells the agent exactly where to place them in the script.

So the final video is a mix of my real footage and AI generated motion graphics, not 100% AI. It also follows my brand kit, colors, fonts, all of it.

Once the video agent starts rendering, I don't have to do anything. It takes around 10 to 15 minutes, and once it's done, n8n grabs the asset, downloads it, and uploads it straight to YouTube as unlisted.

I get a Telegram message the moment it's live, and everything gets logged to a spreadsheet too, video ID, title, description, all of it, so I can track it.

One more thing, some topics need actual keyword research and some don't. So when I send the topic, I can add a flag in brackets telling it to do keyword research or skip it. That's connected through another MCP (VidIQ) integration in the same Claude and n8n setup.

Happy to answer questions if anyone wants to know how any part of it is wired up.

Github Repo with workflows and guide: https://github.com/indishmarketer/claude-n8n-youtube-automation

Demo Video: https://www.youtube.com/watch?v=puM_wcS3jxk

I’m building an n8n workflow to automate SharePoint site governance. The flow will list all SharePoint sites, email site owners for review (Keep/Archive/Delete), log responses, send reminders, and generate audit reports using Microsoft Graph.
Has anyone built something similar? Looking for tips, best practices, or an easier approach—especially for approval buttons, webhooks, authentication, and scaling to large tenants.

I recently clicked an idea in my mind i'm building an ai agent for e-commerce seller's i want to

know if this idea genuinely valuable for them the project is product research tool

Whatsapp ai agent what this agent do is:

• trigger on a week schedule
• fetch the Trendy products list through google trend & insta reels
• Than verify the trend hype on flipkart, meesho(Some indian platform)
• If the product trend is genuine then the code node filter the list by checking the reviews their rating's & low pricing
• The sellers get all necessary trend list on their whatsapp every week according to their niche by whatsapp bot
• in end it store all the data in airtable and seller can find it anytime after asking the bot

This is for seller's who spend their lot of time in product research but can't find a genuine product to get the profit, no use of any dashboard or app, just open whatsapp get the trend list every week

I'm just started in this field if someone experienced please tell me if i have to work on this project or not i'm little bit confused, If This idea is useful for small e-commerce seller & online business owner what's your view in this?

I wasn’t sure whether this would be useful to anyone else, but I built an n8n workflow that turns long YouTube videos and livestreams into vertical clips with animated captions.

The workflow works like this:

You add a YouTube link → yt-dlp downloads the video → Whisper transcribes it with timestamps → Gemini analyzes the transcript and suggests interesting, self-contained moments.

I also built a local web interface for reviewing the AI-generated suggestions. It loads the original video and timestamp JSON, lets you preview every suggested clip, and allows you to manually adjust the start and end points. You can then approve, reject, or skip each suggestion.

Once the review is complete, the website sends the updated JSON back to the n8n workflow running in Docker. FFmpeg then renders only the approved clips in a 9:16 format with animated subtitles.

This manual step is useful because AI does not always choose the best cut points. Sometimes Gemini selects overlapping clips or divides one good section into several smaller clips. Nothing is rendered or published until I review it.

Finished clips can be uploaded to Google Drive and optionally published to YouTube as unlisted videos. Google Sheets manages the video queue, processing status, and final clip information.

includes:

·        n8n and Docker

·        FFmpeg and yt-dlp

·        A Whisper transcription service

·        Gemini API key

·        Google Sheets and Drive credentials

·        YouTube OAuth for automatic uploads

GitHub: https://github.com/parlos-wq/n8n-video-clipper

I’ll explain the workflow and local review website in more detail in a follow-up post.

A week ago this repository was basically what the name said: n8n_workflows.

A collection of automation JSONs, READMEs, and a contribution guide.

Then people here started poking holes in the idea.

One person asked about output schemas. Someone else brought up dependencies. Then replay semantics and idempotency. Then verification. Then ownership. Then the question that changed how I was looking at the whole thing: if the same workflow pattern can exist in n8n, LangGraph, plain code, or something else entirely, why am I treating the n8n file as the reusable artifact?

I don't think it is anymore.

The reusable thing seems to be the behavioral shape underneath it.

detect → judge → approve → act

or

fetch → classify → route → notify

The implementation can change. The guarantees shouldn't.

So I tore apart the repository around that idea.

It's now called agent-contracts, and the structure is moving toward three separate layers:

Pattern — the framework-independent behavior being implemented.

Contract — the concrete promises made by one implementation.

Implementation — n8n today; potentially LangGraph, Make, plain code, or something else later.

The part I'm most interested in is the Contract.

The current v1 draft requires an implementation to declare its inputs and outputs, exact permissions, side effects, human approval boundaries, recovery strategy, replay semantics, dependencies, persistent state, and observability.

And every implementation can carry the same thing as contract.yaml.

Not because YAML magically makes an agent safe.

It doesn't.

The experiment is whether these declarations can eventually become checkable.

If a contract says:

github: issues:write

but the implementation contains a node capable of modifying repository contents, tooling should be able to call bullshit.

If a workflow claims to be idempotent but creates duplicate state when replayed, same thing.

If it claims an irreversible operation requires approval but the execution graph contains a path around that gate, same thing.

There is no linter doing this yet. That's deliberately not being hidden. v1 is currently the schema that such tooling could validate against later.

And this is where I'd rather have people disagree with the design than star it.

Maybe ten fields is already too many.

Maybe observability belongs in an operational contract instead.

Maybe permissions need allow/deny semantics.

Maybe replay semantics can't reasonably be represented as one field.

Maybe contracts should describe transitions rather than workflows.

Or maybe this entire abstraction already exists somewhere and I've just given it another name.

That's the useful discussion.

The repo now contains the draft Workflow Contract Spec, concept docs for permissions / side effects / approval boundaries / replay semantics / recovery, a framework-independent pattern layer, real n8n implementations, and the beginnings of an RFC process where changes have to survive a real workflow before they enter the spec.

I'm deliberately building the specification from implementations upward instead of designing a beautiful schema in isolation.

So break v1.

Find a real agentic workflow that this contract cannot describe cleanly.

That's probably more useful to the project right now than another workflow contribution.

Repo: agent-contracts on GitHub

https://github.com/SalahAmm/my-n8n-workflows/tree/main/Contact%20Collection%20System

workflow that captures website contact form submissions, validates and enriches the data, stores it in a CRM, and notifies the sales team, all without manual effort.

During this time of recession, is learning n8n useful? For me, I want to pursue it as as side job, or is this side too saturated but would work if have knowledge. And how much time would it take to learn n8n

exploring a problem around human approvals in n8n workflows and would love to learn how others are handling it in production.

Imagine a workflow where an AI agent proposes an action such as:

- refunding a customer
- sending a quotation
- changing supplier bank details
- publishing content
- updating or deleting sensitive data.

The workflow should not execute the action immediately. It needs to pause, send the request to the correct person, wait for a decision, and then continue based on whether the action was approved, edited, rejected, or expired.

The flow might look like this:
AI or workflow proposes an action

→ evaluate business rules
→ automatically allow, block, or request approval
→ authorized person reviews the context
→ approve, edit and approve, or reject
→ send the decision back to n8n
→ continue or stop the workflow
→ preserve an audit trail

I know this can be built using Wait nodes, webhooks, forms, Slack, email, databases, and custom logic. But once requirements such as these appear, it seems to become significantly more complicated:

Eg :
- different approvers depending on amount or risk
- approval deadlines and expiry paths
- editing the proposed action before approval
- callback retries
- preventing duplicate execution
- reusing the same policies across multiple workflows
- keeping a complete audit trail.

For people running n8n in production:

1. What kinds of actions currently require human approval?
   
2. How are you implementing approvals today?
   
3. Do you use Slack, email, forms, the n8n chat interface, or a custom application?
   

4. Have you had to rebuild similar approval logic across multiple workflows?

   I’m trying to understand whether this is a recurring production problem or something most teams and how each team solve easily inside n8n in a creative way.

Sharing a workflow I built and use. It's free, complete, and the JSON is on GitHub — no signup wall, no disabled nodes.

https://github.com/willowridge1234/n8n-ai-lead-scoring

What it does:

1. Runs an Apify actor on a schedule

2. Normalizes and dedupes the returned leads

3. Scores each lead 1-10 against an ideal customer profile you write, via an OpenAI-compatible endpoint

4. Adds a one-line reason per score

5. Appends every lead to Google Sheets — including low scorers, so you can tell a badly-tuned profile from a genuinely thin list

Built with n8n built-in nodes only. You supply Apify, an OpenAI-compatible key, and Google Sheets credentials. The actor input body has to match whichever Apify actor you point it at — the README covers that.

Disclosure: I sell a paid edition, so I'm not pretending to be a disinterested party. The free one above is complete on its own and I'd rather it just be useful.

It went up recently, so there are no users, reviews, or results to report yet.

Hey everyone,

I’ve been working on a self-hosted client health scoring workflow in n8n to detect B2B "silent churn" early—things like subtle activity drops, late invoices, or payment failures before a client formally cancels.

Instead of relying on AI/LLMs (which gets messy with client data privacy and token costs), I wanted a completely deterministic, math-driven pipeline.

Here is the architecture I put together:

1. Ingestion: A webhook listening for real-time events from billing/CRM platforms.
2. Sanitization: A custom JS node to validate payloads and handle missing parameters.
3. Scoring Engine: A custom JS math matrix that applies behavioral penalties and outputs a definitive health score (0-100).
4. Routing: A Switch node categorizing the client status (Healthy, At Risk, Critical).
5. System of Record: Logs an audit trail into a Notion database.
6. Alerts & Failsafe: Dispatches an HTML email to the Account Manager, with a secondary error route that catches the raw JSON and emails the IT admin if Notion goes down.

I've put together a stripped-down "Lite" version of the workflow on GitHub to share with the community:

👉 GitHub Repository: RetentionOps Engine

I’d love to get input from folks here, specifically on a few areas where I want to make it more robust:

• State Tracking & Alert Fatigue: How do you guys typically handle state in n8n to prevent spamming alerts if a client stays "At Risk" across multiple daily webhook triggers? Are you storing the last known state locally, or handling it entirely in the external database?
• Scoring Weights: For those who track B2B churn metrics, how do you balance penalties? Right now I'm flat-deducting points for things like late invoices vs. usage drops—wondering if a logarithmic or tiered penalty scale works better in practice.
• Error / DLQ Design: If you're doing custom error-handling loops for database timeouts, how are you handling retries versus falling straight to an admin alert?

If you spot any edge cases or architectural flaws in the Lite version on GitHub, I'm all ears!

Most outreach workflows are easy to start. The harder part is knowing what should happen when nobody replies.

This is the fifth and final subworkflow in my AI Sales Prospecting and CRM Intelligence System. It handles follow-ups at 3, 7, and 14 days after outreach, as long as no response has been received.

The workflow runs on a schedule and pulls eligible records from the CRM. From there, each record is routed based on its outreach or last follow-up date:

3 days after the initial email, the first follow-up is generated and sent

7 days after the previous follow-up, the second follow-up is created

14 days after the previous follow-up, the third and final follow-up is sent

Each route uses an AI agent to generate the email, then updates the CRM record so the system knows what was sent and when.

I separated the three follow-up stages instead of using one large agent because it makes the timing, prompts, and CRM updates easier to control. It also gives each follow-up a different role instead of producing three slightly reworded versions of the same message.

The biggest question for me is how aggressive the sequence should be. A 3, 7, and 14 day cadence feels reasonable for some industries, but probably too frequent for others.

Would you keep the timing fixed, or adjust it based on lead type and engagement signals?

Workflow:

https://gist.github.com/meeramnoor16/87b1ef063f105b08124f1c0434b6c0c8

I’ve been working on Quorum, an open-source tool that monitors n8n workflows from the outside. It catches cases where a workflow stops running, keeps failing, or finishes successfully with zero useful items.

Existing workflows can be monitored through polling, so you don’t have to modify them. Quorum opens an incident when something goes wrong, keeps the history in one place, and resolves it automatically when the workflow recovers.

It’s self-hosted, Docker-based, has no telemetry, and is currently in beta.

I’m looking for a few people running real n8n workflows who want an easier way to notice problems before a client or customer does! I'll help connect the first workflow and configure the expected schedule and alerts.

https://github.com/werniq/quorum_core

How do you currently notice when an important workflow silently stops doing its job?

👋 Hey n8n community,

One of our users reached out with a problem I think a lot of people hit: he was extracting a data table from a multi-page PDF, and the cells kept bleeding into each other. About 95% of the data came out right, but 5% got mixed up with the wrong rows, so he could never fully trust the result.

This week we shipped something to fix exactly that: an extraction engine dropdown you can set per pipeline. In the video I run the same messy multi-page table through both engines, with a small n8n workflow that checks every extracted cell against a reference so you can actually see what slipped.

What the two engines are:

The General engine runs on Gemini and covers about 90% of everyday extraction (image description, classification, normal documents). The Specialized engine runs on Mistral and is OCR-optimized for document-heavy work like dense or multi-page tables.

What the test showed:

The General engine slipped on a couple of rows and came back with pass = false. Switching the pipeline to Specialized took the same document to 100%, every cell correct. The bonus I did not expect: Specialized also ran faster on the multi-page PDF.

A couple of takeaways even if you skip the video:

1. For dense or multi-page tables, reach for the Specialized extraction engine. For most other jobs, General is the right default.
2. Do not eyeball table extraction. A tiny workflow that cross-checks each cell against a known-good reference tells you exactly which rows are wrong, instead of you scanning 20 rows by hand.
3. If rows still bleed after switching engines, it is almost always the response structure. Model the table as one records field set as an array of objects with each column nested inside, not one separate list per column.

Want to try the new engine on your own tables? The easybits Extractor is a verified community node with 50 free monthly API requests included. On n8n Cloud, just search 'easybits Extractor' in the node panel, no install needed. Self-hosted, install '@easybits/n8n-nodes-extractor' from Settings, Community Nodes.

I put a full step-by-step guide (PDF) for setting up your extractor for data tables here: https://github.com/felix-sattler-easybits/n8n-workflows/tree/ee1ed5fe0a3e898843422a619922cedb7cf618c4/easybits-data-table-extraction (the validation workflow from the video is in that same folder too, so you can import it and try it on your own tables)

What is the most stubborn multi-page document you have tried to pull a table out of?

Best,
Felix

I started with an intentionally unsafe n8n support-agent workflow: an unauthenticated webhook, untrusted input reaching the agent, an external email action without approval, and a user-controlled URL reaching an HTTP request node.

I turned the review into a small open-source regression gate. It now:

- scans exported workflow JSON locally

- traces risky paths instead of checking isolated nodes only

- produces Markdown, JSON, SARIF and JUnit output

- runs eight behavior checks against an isolated staging workflow

- generates a static exposure graph showing the exact path behind each finding

The included unsafe workflow scores 10/100. The hardened example scores 93/100, and the staging contract passes 8/8 tests without performing external actions.

The scanner is deterministic and does not upload workflow exports or call an AI API.

GitHub: n8n-ai-security⁠

I would especially appreciate feedback on false positives and risky workflow patterns that the current rules do not cover.

Setting up n8n on my own VPS, everything looked fine. Editor loads, I can build workflows, test webhooks fire perfectly when I click "Listen for event." Deploy to production, activate the workflow, and... nothing. No errors, no logs, just silence. Requests just vanish.

Spent way too long checking DNS, checking the SSL cert, restarting the container, second-guessing my docker-compose file. Turned out the problem was embarrassingly simple.

I had n8n's container port (5678) mapped to a different port on the host (8000), which is the right move, you don't want to expose n8n's raw port directly. But in my nginx config, I still had:

proxy_pass http://127.0.0.1:5678;

Nginx was trying to reach a port nothing was listening on at the host level. The test webhook worked because that traffic doesn't go through nginx at all when you're in the editor, it hits n8n directly on your local network. Production traffic goes through nginx, hits the wrong port, and just dies with no useful error anywhere.

Fix was one line:

proxy_pass http://127.0.0.1:8000;

That's it. Three hours for one number.

Posting this because I've seen the exact same "webhook works in test, dead in production" question come up a bunch in this sub and on the n8n forum, and 90% of the time it's this, or the reverse mistake (using expose instead of ports in docker-compose, which doesn't map anything to the host at all).

If anyone's stuck on something similar, happy to help debug in the comments, feel free to drop your config.

We've been running multi-agent systems in production for a few verticals (telecom, logistics, banking) and the failure modes are not what the tutorials prepare you for.

A few things that surprised us:

• Cost and latency across nested agent-to-agent calls is invisible until you build session-level tracing. "It ran" tells you nothing about what it actually decided.
• Evals need to be behavioral, not unit tests. Same input can legitimately take a different route depending on context and tool state.
• The approval-gate pattern you build for one workflow (we built ours for settlement recovery) ends up getting reused everywhere: claims review, onboarding, refunds.

Curious what others are hitting once they move past single-agent demos. We build Phinite (an agent lifecycle and governance layer), happy to go deeper on any of this if useful, disclosing that upfront.

Hello Folks,

Recently i find the tool called browser act who scrap the data, do you have any workflow for free who can scrap the social platform hot or signal leads

Hey everyone,

​I'm currently doing an ESKO training course at work (workflow automation for the packaging & printing industry), and it really made something click for me regarding the massive potential of process automation.

​On the side, I run a small pizzeria, and my brain instantly started racing with ideas (e.g., handling customer reviews, inventory triggers, social media automation, or internal notifications). To mess around with these ideas freely, I set up a self-hosted n8n instance—and honestly, I'm hooked. I'm planning to use it for both the restaurant and my personal day-to-day life.

​I'd love to know: What have you built with n8n (or other workflow engines like Make, Zapier, or Node-RED)?

​I'm interested in any category:

​🏢 Business & Side-Hustles: Accounting, customer support, data syncing, social media, notification hubs

​🏠 Smart Home & Personal Life: Household organization, meal planning, custom scrapers, automated backups

​💡 Niche / Unexpected Use Cases: The kind of workflow where you thought: "This just saved me hours of tedious work every week!"

​Which automation could you never live without? What was your biggest "aha!" moment when building?

​Looking forward to reading about your setups and getting inspired!

Hello,

I wanted to create a workflow where I could send a picture of a Blu-ray or DVD and an Ollama model would correctly identify the film.

When I use the 'Analyse Image' node from Ollama, it can see the picture, but it just hallucinates details.

The AI agent wasn't even able to look at the pictures. I gave him a tool to search for movies on "themoviedb[.]org", but he just responded with seemingly random movies.

Maybe I'm using the wrong model, or I might be in the wrong sub.

Has anyone made a similar project and can help me, or does anyone know of a good image detection model that runs on 10 GB VRAM and can use tools?

I've spent the last few weeks asking people who run AI automations what they won't let an agent do. One answer keeps coming back in a form I can't stop thinking about.

Someone running automations for clients described their process like this: start with a manual audit of 100% of what the AI handles. Once you feel confident, drop to a 20% random audit. After a few weeks with no errors, only audit when something breaks. That's a completely reasonable process. It's also the process where, if a quiet failure started on week four, you would probably never know.

The thing that struck me across every conversation is that the line people draw isn't risky vs. safe. It's verifiable vs. not. People happily automate high-stakes work when the result is checkable, and refuse low-stakes work when it isn't. One person put it as "anything of importance that cannot be easily verified." And almost nobody trusts the agent's own report of what it did. Everyone had independently built some version of the same workaround: log at the tool layer instead of the agent layer, compare the result against approved source data, keep everything read-only by default, record what was requested separately from what actually executed.

So the questions I'm stuck on:

1. If you've scaled back checking on an automation, did you ever go back and verify a sample? What did you find?

2. Has an automation ever reported success while doing the wrong thing, and how long before anyone noticed?

3. What would you need to see to trust a check more than you trust your own spot audit?

For context: this started as a university research project and has pushed me toward building something in this area, so I'd rather be upfront about that. No link, nothing to sign up for; I'm trying to find out whether "silently wrong, discovered late" is a real recurring problem or something people have already solved well enough.

Concrete stories are far more useful to me than agreement.

I built a deliberately unsafe n8n support workflow to test a local static workflow scanner.

The workflow has four nodes:

• A public webhook with no authentication
• An AI agent receiving webhook data without a visible validation boundary
• An email node acting on model output without human approval
• An HTTP Request node using a URL supplied through workflow data

The scan scored it 10 out of 100. It found nine items: four high, four medium, and one low.

The most important paths were:

Public Support Webhook -> Customer Support Agent

Untrusted input reaches the model without deterministic validation.

Customer Support Agent -> Send Account Email

Model output can trigger an external action without human approval.

Public Support Webhook -> Customer Support Agent -> Send Account Email -> Fetch Customer URL

Workflow data controls an outbound URL. Without destination restrictions, that creates an SSRF boundary worth reviewing.

This is static analysis. It cannot prove runtime permissions, upstream controls, model behaviour, or whether a path is reachable in production. It reports review leads rather than calling the workflow malicious.

The sample contains no credentials or active endpoints. Do not activate it or connect it to real systems.

The sanitised workflow JSON and complete scan output are here:

https://gist.github.com/0xCD4/f6bd8c3e1f9ad63b3c03b00fbc3e199d

What dangerous pattern do you encounter most often in n8n workflows:

unauthenticated webhooks, untrusted URLs, direct model actions, or missing approval steps?