I used n8n, Telegram, and Google Sheets to automate publishing products to WooCommerce. No more manual work! It reads the product queue from Sheets and publishes it to WooCommerce via POST request.
More automations: Join our community: https://go.phonezait.de/
Wanted to share a workflow I built that's been running in production for a couple months now. It handles the entire video pipeline autonomously: script generation via AI agent, text to speech, Manim-based animation rendering, thumbnail generation, and YouTube upload with scheduling. No manual editing or touching it after it triggers.
Screenshots below show the actual n8n canvas along with the two YouTube channels it's currently running: Math Unlocked (@MathUnlockedYT) and Financial Reality Check (@FRCFinance), both with videos scheduled weeks out.
Happy to answer questions on the node structure, how the AI agent handles script generation, or how the render/upload pipeline is wired if anyone's building something similar for their own content.
Been meaning to solve my own content problem, so I built this in n8n over the weekend. Sharing the setup in case it's useful to anyone.
What it does: every Monday it pulls the most-viewed YouTube videos in my niche, has an AI model break down why each one worked (hook type, emotional trigger, format), then generates 7 original content ideas — each with a hook line, format, structure, and caption starter — and drops them as clean rows into a Google Sheet. Also pings me on Telegram when it's done.
The pipeline:
Schedule Trigger (weekly)
YouTube Data API → most-viewed videos in-niche (free, official API)
Code node → rank + prep the top 10
OpenAI (gpt-4o-mini) → analyze the viral patterns
OpenAI → generate 7 structured ideas as JSON
Code node → split JSON into one row per idea
Google Sheets (append) + Telegram (notify)
Stuff I learned the hard way:
Started with Reddit as the source but n8n Cloud's shared IPs get 403'd on anonymous requests — switched to the YouTube Data API and it's honestly better data (real view counts = a cleaner viral signal).
Ask the AI for JSON, not a markdown table — a table dumps into one ugly cell; JSON split into rows gives you clean columns.
gpt-4o-mini is more than enough for this and keeps the cost basically nothing.
Runs completely hands-off now. Happy to share more detail on any node if anyone wants to build their own.
There are a few tools out there that do something like this, but they're closed source, and a couple even send your workflow to a server or an LLM to do the "sanitizing." That kind of defeats the whole point: if you have to hand your private data to someone else in the first step, it was never private. For a tool whose entire job is protecting sensitive data, "trust us, we won't look" isn't good enough.
So I made n8nRedact. Paste or drop a workflow, get a sanitized copy back.
First, the problem. n8n doesn't strip anything on export. Even though your actual credentials aren't in the JSON, a surprising amount still leaks: credential names, cURL auth headers in HTTP Request nodes, Airtable base/table IDs, Postgres table names, Notion page IDs, Telegram chat IDs, hardcoded URLs and emails, your instance ID, and webhook tokens buried inside URLs.
What it does:
- Detects and replaces the sensitive stuff: credentials/keys, emails, URLs, UUIDs and hex IDs, Airtable/DB resource IDs, Telegram chat IDs (string and numeric), phone numbers, instance IDs, and more.
- Format-preserving. john@acme.com becomes user1@example.com, not [REDACTED]. The output stays a valid, importable workflow.
- Deterministic. The same value always maps to the same fake, so cross-node references still line up.
- Side-by-side diff so you see exactly what changed.
- Toggle rules on/off, with live counts of what was found.
- n8n expressions (={{ $json.foo }}) are preserved, not mangled.
Why you should be able to trust it:
- 100% client-side. Nothing is uploaded, and it can't be. There's a Content-Security-Policy with connect-src 'none' that physically blocks the browser from making any network request. Even a compromised dependency couldn't exfiltrate your paste. There's an automated test that fires a fetch and asserts the browser blocks it.
- Open source, so you can verify all of the above instead of taking my word for it.
- Works offline after first load.
Free, no accounts, no analytics, no cookies.
Repo: https://github.com/Shuffzord/n8nRedact
Live: https://shuffzord.github.io/n8nRedact/
Would love feedback, especially edge cases where it misses something or over-scrubs. If you've got a weird node type that leaks in a way I haven't handled, drop an example (anonymized 😉) and I'll add a rule.
Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.
One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.
Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.
Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.
A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.
Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.
It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.
For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.
npm install -g omniroute
GitHub: https://github.com/diegosouzapw/OmniRoute · Site: https://omniroute.online
Would value a critique of the routing/compression architecture from this crowd.
Wanted to share a workflow I built for cleaning up messy PDFs (scanned notes, rough drafts, unformatted text dumps) sent via Telegram.
How it works:
Send a PDF to my Telegram bot
n8n extracts the raw text from the PDF
A "Cleaner Agent" (GPT-4o-mini) strips out OCR noise, fixes broken sentences, normalizes spacing
A "Structurer Agent" re-organizes the cleaned text into logical sections using a content schema parser
A "Summary Agent" generates a short summary alongside the full cleaned doc
Everything gets built into a properly formatted Google Doc (headings, bullet points, etc. — not just a wall of text)
Exported as PDF, then both the cleaned PDF and a summary message are sent back to me on Telegram
Stack: n8n + OpenAI (gpt-4o-mini) + Google Docs API + Telegram Bot API
Biggest technical hurdle: pdf-lib doesn't work on n8n Cloud, so I had to route through Google Docs batchUpdate → Drive export → PDF as a workaround instead of manipulating PDFs directly.
Happy to answer questions about the node setup or the agent prompts if anyone's building something similar. Also open to feedback if anyone sees ways to simplify the chain.
A failure mode that does not get talked about enough in n8n: the execution shows success, so everyone assumes it worked, but green only means the run finished without throwing. It does not mean the thing you cared about actually happened. The ones that burn people are the quiet ones. A scheduled flow that stops firing but still shows Active, no error anywhere. Or a token that expires and comes back 200 with an empty list, so the flow maps nothing forward and quietly writes blanks. Neither hits the Error Trigger, because nothing errored.
The cheapest thing that helps, no tool needed: for the flows a client depends on, add a check at the very end that the real outcome exists, the row actually landed or the email actually went, and have it shout if that comes back empty. And separately account for the run that never started, since a missing execution leaves nothing to alert on. What does everyone else do here, an error workflow plus checks, an outside pinger, or something else?
Hello everyone!
I'd like to share another n8n project I built: a personal AI assistant for Telegram.
/new starts a new conversation by clearing the current chat history while keeping your saved preferences./clear permanently deletes all stored preferences without affecting the current conversation.The idea was to create an AI assistant that combines long-term memory with everyday productivity tools. By remembering user preferences and integrating with Google services, conversations become more personalized and practical over time.
I'd really appreciate any feedback or suggestions for improvements. This project will be part of my portfolio.
If you're looking to automate your own workflows or business processes, feel free to reach out:
https://zhrssh.github.io/contact/
👋 Hey n8n community,
A few of you asked for more detail after my Purchase Order extractor post yesterday. The build looked simple on the surface, but a handful of things bit me along the way. Here are the five that cost me the most time, in case they save you some.
1. Only numbered rows are real articles. The POs had little note lines wedged between items ("2 Box", a location note under a lock, etc). My extraction kept swallowing those into the neighbouring product name, so one row would come out as two items mashed together. The fix wasn't in the workflow at all, it was in the document description I gave the extractor: spell out that only rows with a number in the No. column are real articles, and that unnumbered lines are notes belonging to the row above. That one paragraph cleaned up every merge. Lesson: when a document extraction misbehaves, describe the document better before you touch the nodes.
2. Keep numbers as text until you've checked for empties. Tempting to pull quantity and price straight as numbers. Don't, at least not yet. A missing field comes back as the string "null", and if the field is typed as a number that signal turns into a 0 or a real null and you lose the ability to spot the miss. I keep everything as text, run my checks, then cast to a number afterwards. Clean signal in, clean data out.
3. One helper to catch every flavour of empty. "Empty" is never just one thing. Across the docs I saw real null, the string "null", empty strings, and whitespace. I stopped writing one-off checks and made a single isMissing() helper that catches all of them, then used it everywhere. If a field is missing, the workflow flags it on the form's completion screen with the document name and which field failed, so my friend knows exactly which PO to eyeball instead of trusting the sheet blindly.
4. The Google Sheets checkbox that quietly broke everything. This one nearly broke me. New rows kept landing at the very bottom of the sheet instead of the top empty row. Turns out I'd added a checkbox column with Insert > Tick box, which silently writes a FALSE value into every one of the 1000 cells in the column. The Append node counts those as data, so it always appended below them. If you want checkboxes, add them through Data → Data validation instead, which draws the box without writing a value. Hours lost to a column that looked empty but wasn't.
5. Batch size 1 is not optional here. The extractor node bundles every input item into a single call, so if you hand it two PDFs at once you get one jumbled result. Wrapping it in a Loop Over Items with batch size 1 means each document gets its own clean pass. Small setting, big difference, and easy to miss until your two-file test comes back merged.
The whole thing runs on the easybits extractor node for the actual PDF reading, the rest is stock n8n. If you want to try the Purchase Order extractor yourself, feel free to grab it here:
https://github.com/felix-sattler-easybits/n8n-workflows/blob/c38749a68fd6ea4ae6ebff41789d35cceaacdef1/easybits-purchase-order-extractor-workflow/easybits_purchase_order_extractor_workflow.json
What's the dumbest time-sink you've hit on a build that looked easy? Always happy to hear how other builders tackle this stuff.
Best,
Felix
👋 Hey n8n community,
Last week I posted a workflow I built for a friend who runs an online shop (find it here). He called me again a few days later with a new headache: he's drowning in Purchase Orders. Every single one gets opened by hand, the data typed into a Google Sheet, and that sheet uploaded into his ERP to update his numbers. Hours a week, pure copy-paste.
So I built him something to kill that step. He uploads the PO PDFs through a simple n8n form, and a structured Google Sheet comes out the other end. He just downloads it and pushes it to his ERP.
How it's set up:
The form accepts multiple PDFs at once, so he can batch a whole stack instead of doing them one by one. Each PO loops through on its own so nothing gets jumbled.
The extraction runs on the easybits Extractor node (@easybits/n8n-nodes-extractor). I set the field structure up in two parts: the header fields that appear once per PO (PO number, PO date, delivery date, mark for, PR number, reference no), plus an articles array for the line items, each holding article name, unit and quantity. That array is the key bit, it gives you one entry per row of the PO table, and I flatten it into one sheet row per article with the header details repeated on each.
Two things I added because real documents are messy:
Error flagging. If any field comes back empty, the completion screen lists which document and which field didn't extract cleanly, so he knows exactly which PO to double-check instead of trusting it blindly.
Document name column. The original filename lands in the sheet next to every row, so if a number looks off he can jump straight back to the source PDF.
Workflow JSON is on GitHub: https://github.com/felix-sattler-easybits/n8n-workflows/blob/c38749a68fd6ea4ae6ebff41789d35cceaacdef1/easybits-purchase-order-extractor-workflow/easybits_purchase_order_extractor_workflow.json
I also made a short video showing how the workflow works.
Anyone else automating document-to-sheet data entry? Curious how you're handling the messy multi-line rows – that was the trickiest part to get right.
Best,
Felix
If you're new to n8n and mixing these up, here's the short version:
$json is the current item's data in the current context. Use it inside a Code node set to "Run Once for Each Item", or inline in expressions like {{ $json.email }}.
$items() is the old-school way to grab an array of items from a specific node. It still works in a lot of workflows you'll find online, but it's legacy syntax. The modern equivalent is $input.all() inside a Code node, or $('Node Name').all() in expressions — both are more explicit about which node's data you're pulling.
Rule of thumb I use: if I'm working with ONE item, $json. If I need ALL items to loop, aggregate, or compare, $input.all(). I basically never reach for $items() anymore, but it's worth recognizing when you see it in older templates.
Curious if anyone still has a real use case for $items() over $input.all() — haven't run into one myself.
I used n8n to automate order refunds by connecting a webhook to Google Sheets, Stripe API, and Telegram. No more manual processing!
More automations: Join our community: https://go.phonezait.de/
A few weeks ago, I shared a workflow that handles bookings across two courts/calendars with conflict checking. This is the next chapter.
Instead of users filling a form, I wanted an AI agent to collect booking details conversationally through chat — then pass the data into the same workflow.
Sounds simple. It wasn't.
I built a fully automated booking system for a padel club with an AI agent front-end — no code, just n8n
Padel is blowing up where I'm from and most clubs are still taking bookings over WhatsApp manually. I wanted to fix that for a 2-court setup.
Here's what I ended up with.
**What it actually does:**
\-A customer chats with an AI agent — talks naturally, no forms
\-Agent collects the details conversationally
\-Passes structured data into a booking workflow
\-Workflow checks availability, assigns the first available court, and confirms
\-Everything syncs to Google Sheets automatically
\-Works for new bookings, updates, and cancellations — including edge cases like overlapping time slots on updates
A customer types "book tomorrow at 8 for an hour" and gets a confirmed booking with an ID. That's the whole experience.
**Why I split the AI and the workflow into two separate pieces:**
Early version had the AI doing everything — checking availability, assigning courts, generating IDs. It hallucinated constantly.
The fix was simple: AI only talks to the user. The workflow handles all the logic. The agent calls the workflow like a tool, gets a result back, and translates it into a friendly reply.
Much more reliable. Much easier to debug when something goes wrong.
**The core insight:**
Keep AI in the conversation layer. Keep deterministic logic in the workflow layer. When I mixed them, things broke in ways that were hard to debug. When I separated them, both parts became much easier to reason about and fix.
**What this could work for beyond padel:**
Any multi-resource booking scenario — tennis courts, meeting rooms, recording studios, parking bays. The core pattern (AI conversation layer → deterministic booking backend → calendar + sheets sync) is reusable.
Full workflow is on GitHub if anyone wants to dig into it or adapt it for their own use case. Happy to answer questions or help anyone trying to build something similar.
https://github.com/rajakumarbakhtawar-dotcom/padel-test-2-courts/issues/1#issue-4736136194
**Curious what others are doing:**
If you're using AI agents with n8n tools — how much logic are you putting in the prompt vs the workflow?
And how are you handling ambiguous user input before it reaches your tools?
Hi guys,
Last time I posted my prototype workflow. Now I’m trying to set it up for real-world usage using n8n + Meta WhatsApp Cloud API.
When I try to add my phone number in Meta, I get this error saying the number is already registered to a WhatsApp account.
My initial understanding is that I may need to convert or migrate the number to WhatsApp Business / WhatsApp Cloud API.
What I want to do is quite simple:
I want to use my normal WhatsApp number and connect it to my workflow only to sort/classify message priority, for example urgent, normal, or low priority.
My question is:
Is it possible to use a normal WhatsApp number for my workflow? If yes, how?
ok so this is gonna be long sorry in advance, but I spent my precious weekend comparing n8n scraping workflows against just writing the damn scraper in Python and I have some thoughts to share with yall.
Started because my unemployed friend sent me one of those "I automated my job search with n8n" posts and I was like, not with this again, there's like a million automations already created, why did you even bothered? But he somehow convinced me to try replicating something similar on my side, so basically, I had to try it. Mainly just scraping product listings off a marketplace site, turned on my n8n, dragged in an HTTP node, a Cheerio node for parsing, a loop, a Google Sheets node at the end. All it took maybe 40 minutes and it worked first try which felt great.
Like the majority of the projects I've worked on, it then started throwing Cloudflare challenges after around 600 requests and that's where it stopped feeling great. I tried putting in some cheap datacenter proxies I had lying around from an old project, didn't help much, IP reputation on datacenter ranges is just garbage on anything halfway protected these days. Switched to a residential proxy pool instead and got further but still kept tripping something, which is when I remembered the IP is only half the story, the actual fingerprint matters just as much if not more. (take notes folks).
So I go to fix it in n8n and immediately went full stop, everyone who's done this before already knows about, which is that the visual nodes are amazing for the happy path and genuinely miserable the second you need anything custom. wanting to rotate user agents with actual entropy, not just a static list cycling in order. wanting real TLS fingerprint control so your handshake doesn't scream "I am a script" before you've even sent the request, wanting a headless browser session that actually behaves like a person scrolling and pausing instead of firing requests like a machine gun. none of that is a drag and drop node, you end up writing it in a Code node anyway which is just JavaScript wearing a costume, so you've reinvented half a script but now it lives inside someone else's execution engine and you can't easily version control it or run it locally without spinning up the whole n8n instance.
Compare that to just opening a .py file. requests or httpx if you want async, curl_cffi if the site's fingerprinting you (and these days almost everything past a certain traffic volume is), playwright if you actually need a full headless browser for JS rendered pages. yeah you're typing more in the first 20 minutes, but every single thing is yours, testable, debuggable with an actual setup trace instead of n8n's execution log that sometimes just says "error" and leaves you to guess. and when the scraper needs to scale, you're not paying per execution or fighting workflow timeout limits, you just run more processes or throw it on a queue.
At some point I just gave up taking care of proxy rotation and fingerprint config by hand and pointed the whole thing at a web scraper api instead, basically it felt a little like cheating at first but also I have a day job and the marginal value of me personally maintaining a TLS impersonation layer is zero. Aso tried doing a rough version of the same job in Go for comparison because why not, and that one was interesting for a totally different reason, the speed difference on concurrent requests was kind of stupid honestly, noticeably faster spinning up a thousand goroutines than even async Python, but the dev time to get there was longer and if you're not already comfortable with the language you'll burn an evening just on syntax instead of solving the actual scraping problem. so it's not really "Go is better" it's "Go is better if you already know Go and need raw throughput". One thing I didn't expect going in, mobile proxies actually outperformed residential on a couple of the trickier targets, something about carrier grade NAT making the IP reputation look cleaner since thousands of real phones share the same address anyway. didn't bother testing ISP proxies for this particular target since the site wasn't doing heavy ASN level scrutiny, but I've used them before on stuff where you want the static IP of a datacenter with the trust level of residential, good middle ground when rotation isn't what you need.
Then I poked at a search api for a side piece of this project, pulling SERP results instead of crawling category pages directly, and that ended up being way less of a headache than the rest of the whole ordeal combined, search engines have their own blocking logic obviously but it's a more solved problem than random ecommerce sites running custom bot detection.
What I keep landing on is it's basically a compromise between time to first result and ceiling. n8n wins time to first result by a mile. Python wins ceiling, not even close. Go wins ceiling even further out but only if speed at scale is actually your bottleneck and not, like, getting blocked every 400 requests or so regardless of how fast you can send them, which honestly is the actual bottleneck like 90% of the time, not raw speed.
Anyway I ended up keeping the n8n workflow for the parts that are basically just data movement, sheets, notifications, scheduling, and ripped the actual fetching logic out into a standalone Python script that n8n just calls and waits on. feels like the right choice.
Gotta hand it to my friend, while his solution was probably one of those in the million, this gave me a chance to try out different languages for scraping and whatnot.
Perhaps someone else found a way to make the no code route hold up against fingerprint based blocking, because every workaround I tried inside n8n itself felt like duct tape on duct tape and rinse and repeat.
TLDR: Spent a weekend comparing n8n scraping workflows against Python and Go for the same job, and n8n wins on speed to a working prototype but falls apart fast once a site starts fingerprinting you past basic IP checks. Tried datacenter proxies first (useless), then residential and even mobile proxies (mobile actually did better on a couple targets), but eventually just routed everything through a web scraper api since maintaining fingerprint evasion by hand wasn't worth my time. Python gave way more control for the actual scraping logic while Go only made sense if raw concurrent throughput was the bottleneck, which it usually wasn't compared to just getting blocked. Ended up keeping n8n for the boring data movement parts (sheets, notifications, scheduling) and pulled the real scraping into a standalone script it just calls.
I created a workflow to catch and classify order errors using n8n, Google Sheets, and Telegram. Now I can focus on other things while it handles auth, timeout, and rate limit errors. CJ Dropshipping and WooCommerce are also integrated.
More automations: Join our community: https://go.phonezait.de/
Thank you in advance.
I created an n8n workflow to send daily security news to your Discord
Video Tutorial: https://youtu.be/ZSIyHFEgF2I
Workflow File: https://github.com/th3-ch0s3n-0n3/n8n-workflows/blob/main/Daily_Sec_News.json
Overview and Full Details: https://github.com/th3-ch0s3n-0n3/n8n-workflows/blob/main/Readme.md
This workflow runs on demand (via chat trigger) and performs the following:
The aggregated batch is sent to Gemini 2.5 Flash Lite with a role-prompted CTI analyst system prompt. The model is instructed to use only the provided news batch (no external knowledge) and filter strictly by the following criteria.
numberInputs accordingly).maxItems value in any Limit node (currently 5 per feed).guildId and channelId in the Discord nodes.I used n8n to automate order status updates by connecting a webhook to Google Sheets and routing emails with Gmail - saves me a ton of time
More automations: Join our community: https://go.phonezait.de/
Quick tip for anyone writing Code nodes in n8n: stop accessing nested fields directly.
$json.field.subfield will throw the second `field` doesn't exist on some items in your batch — and with n8n that happens more often than you'd think (APIs returning partial data, webhooks with optional fields, etc).
Just use optional chaining everywhere:
$json.field?.subfield
And if you need a fallback value, stack the nullish coalescing on top:
$json.field?.subfield ?? 'default'
Saved me from a bunch of random workflow failures that only showed up on specific items, not the whole batch — which made them annoying to debug in the first place.
Anyone else have small JS habits like this that cleaned up their Code node errors?