Forem: Jayanth

I Built an n8n Workflow That Generates “Top 10” Videos Automatically (System Design + Lessons)

Jayanth — Wed, 29 Apr 2026 13:45:23 +0000

Why I built this

Creating content manually doesn’t scale.

Even a simple “Top 10” video takes:

research
scripting
editing
uploading

Repeat that daily → it becomes a bottleneck.

So instead of optimizing the process…

I removed myself from it.

What this system does

This workflow automatically:

generates topics
writes structured scripts
creates voiceovers
generates visuals
assembles final videos

Runs on a schedule.

No manual input.

Architecture

`Scheduler (cron)
↓
Topic Generator (AI)
↓
Script Generator (Top 10 format)
↓
Voice Generation (TTS)
↓
Visual Generation
↓
Video Assembly
↓
Upload / Storage`

This type of pipeline is possible because :contentReference[oaicite:0]{index=0} connects APIs and services into deterministic workflows that execute predefined steps reliably. :contentReference[oaicite:1]{index=1}

Step 1 — Trigger (Scheduler)

Cron node runs daily
Starts entire pipeline automatically

Step 2 — Topic Generation

AI generates topics like:

“Top 10 AI tools”
“Top 10 productivity apps”

Insight:

Topic quality = performance

Bad topic → system still runs → bad output at scale

Step 3 — Script Generation

Strict structure:

Hook
Intro
Ranked list (#10 → #1)
Outro

Example:


txt
Top 10 AI tools you need in 2026

#10 ...
#9 ...
...
Why this matters

Structured formats are predictable → perfect for automation


**Step 4 — Voice Generation**
Text → speech (TTS / cloned voice)
Short sentences only
Common mistake

Long paragraphs → unnatural audio → low retention


**Step 5 — Visual Generation**

For each list item:

generate image / clip
map to script section


**Step 6 — Video Assembly**

Combine:

audio
visuals
timing

Output = ready-to-publish video


**Step 7 — Upload / Storage**
YouTube / Drive / S3
store metadata (URL, topic, status)
What actually breaks (real issues)

**1. Garbage input → garbage output**

Automation scales mistakes.

If topics are weak:
→ system produces low-performing videos faster

**2. Generic AI scripts**

Without constraints:
→ repetitive + boring content

Fix:

enforce structure
control output length

**3. Timing + pacing issues**
long segments kill engagement
uneven pacing breaks flow

**4. System maintenance**

n8n workflows are powerful but require setup and maintenance as integrations evolve.


**Key insight**

This is NOT a video generation system.

It’s a content pipeline.

And the difference is:

Manual:
idea → create → edit → publish

System:
data → process → output → repeat


**Why this works**

“Top 10” content has:

fixed structure
repeatable format
predictable output

Which makes it ideal for automation.


**Final workflow (simplified)**
Idea
 → Generate script
 → Generate voice
 → Generate visuals
 → Assemble video
 → Publish


**Final thought**

Most people try to:

edit faster
script better
produce more

But the real leverage is:

Designing systems that produce content without you


**Question for devs**

Anyone here building automated content pipelines?

Curious about:

scaling workflows
handling quality control
avoiding repetitive outputs

Automate UGC Ad Videos with AI (Full Workflow + System Design)

Jayanth — Tue, 28 Apr 2026 16:54:45 +0000

What this builds

An automated pipeline that:

generates ad scripts
creates voice + video
outputs ready-to-use UGC ads

Architecture

`Input Idea
↓
AI Script Generator
↓
Voice Generation
↓
Video Generation
↓
Editing Layer
↓
Final Output`

Step 1 — Script Generation

Use LLM (Gemini / GPT)

Structure:

Hook
Problem
Solution
CTA

Step 2 — Voice Layer

TTS / cloned voice
keep sentences short
natural tone

Step 3 — Video Layer

avatar or stock visuals
sync with audio

Step 4 — Editing Layer

captions
transitions
pacing

What breaks

Long scripts
→ poor pacing
Generic output
→ low engagement
No structure
→ unusable video

Key insight

This is not video generation.

It’s content pipeline engineering.

Full breakdown with screenshot check here - UGC Ads 2025: Automate Videos With AI (Save 100+ Hours)

Use cases

ad creatives
content agencies
social media automation

Question

Anyone here using AI for ad creatives at scale?

Automate Blog Publishing with n8n + AI + WordPress (Full Workflow) published: true

Jayanth — Mon, 27 Apr 2026 14:31:45 +0000

What this builds

A complete automated blog pipeline:

fetch trending content
generate AI articles
create images
publish to WordPress

Architecture

`Scheduler (RSS)
↓
Filter topics
↓
AI content generation
↓
Image generation
↓
WordPress publish
↓
Tracking`

Step 1 — Fetch content (RSS)

pull from news sources
filter last 24 hours

Step 2 — Topic filtering

remove irrelevant content
keep niche-specific topics

Step 3 — AI blog generation

Generate:

title
intro
structured body
conclusion
SEO metadata

Step 4 — Image generation

generate featured image
attach to post

Step 5 — Publish via WordPress API

POST request:

json { "title": "Generated Title", "content": "AI content", "status": "publish" }





**Step 6 — Tracking layer**

Store:

topic
publish date
URL


**What breaks**
1. Generic content

Fix: enforce structure

2. Duplicate posts

Fix: tracking layer

3. SEO issues

Fix: add metadata + structure

For full breakdown with screenshot and workflow template check out [Automate Your Blog with AI : The Complete N8N News-to-WordPress Tutorial](https://elevoras.com/automate-your-blog-with-ai-the-complete-n8n-news-to-wordpress-tutorial/)

**Key insight**

This is not content generation.

This is content infrastructure.


**Use cases**

- niche blogs

- affiliate sites



**Question**

Anyone running AI content pipelines in production?

Curious about scaling + SEO impact.

Automate Instagram Comments with n8n + AI (Full Workflow + Real Issues)

Jayanth — Sun, 26 Apr 2026 11:03:16 +0000

What this builds

An automated system that:

monitors Instagram comments
generates contextual AI replies
optionally sends DMs
tracks everything

Basically:

comment → response → conversation → lead

Architecture

`Instagram Comment Trigger
↓
Fetch Post + Comment Data
↓
Filter (duplicates / spam)
↓
AI Response Generator
↓
Post Reply (Graph API)
↓
Send DM (optional)
↓
Store in DB / Google Sheets`

Step 1 — Trigger (Monitor Comments)

Use Instagram Graph API.

Setup:

poll every 2–5 minutes
fetch latest posts
extract new comments

Why polling?

Because real-time webhook setup is more complex and not required for most use cases.

Step 2 — Filtering Layer (Critical)

Before doing anything, filter:

already replied comments
duplicate users
spam comments

If you skip this:
→ your workflow will reply multiple times to the same user

Step 3 — Extract Context

From each comment, extract:

comment_text
username
post_caption

Why this matters:

AI without context → generic replies
AI with context → relevant replies


**Step 4 — AI Response Generation**

Input:

{{ comment_text + post_caption }}


System prompt example:

You are a helpful assistant replying to Instagram comments.

- Keep replies under 2 sentences
- Be natural and conversational
- Avoid generic responses
- Match context of the post

Output:

short reply
human-like tone
contextual response


**Step 5 — Post Reply**

Use Facebook Graph API:

POST /{comment_id}/replies

Payload:

{ "message": "AI generated reply" }



This posts directly under the comment.


**Step 6 — DM Automation (Optional but Powerful)**

Trigger DMs based on:

keywords (e.g. "price", "link")
or every comment

Examples:

send product link
send lead magnet
send onboarding message

This is where conversions actually happen.


**Step 7 — Tracking Layer**

Store data in:

Google Sheets
Airtable
Database

Track:

username
comment
reply_sent
dm_sent
timestamp

Why?

prevents duplicates
builds lead database
helps debugging


**What breaks (real issues)**
1. Duplicate replies

Cause:

no tracking

Fix:

always store processed comments
2. Generic AI responses

Cause:

no context

Fix:

include post caption + intent
3. API limits

Instagram Graph API has:

rate limits
permission restrictions

Fix:

throttle requests
batch processing
4. Delay vs real-time

Polling = delay (2–5 min)

Tradeoff:

simpler setup
good enough for most use cases


**Key insight**

Most people think this is an "automation problem".

It’s not.

It’s a context + control problem.

Bad input → bad replies → low engagement


**Where this is useful**
creators (engagement boost)
agencies (lead generation)
businesses (auto support)


**Final workflow (simplified)**
Comment
 → Filter
 → Generate reply
 → Post reply
 → Send DM
 → Store data


Anyone here running Instagram automation at scale?

Curious about:

rate limit handling
better DM logic
spam avoidance strategies

Drop your setup

Build a Voice Cloning Auto-Reply Bot with n8n + ElevenLabs (Real Workflow, Not Theory)

Jayanth — Sat, 25 Apr 2026 17:27:22 +0000

Most “AI voice bot” tutorials show the result.

Very few show what actually breaks when you try to build one.

This is a full working workflow using:

n8n (automation)
ElevenLabs (voice cloning)
AI model (response generation)

And more importantly , what you need to get right for it to actually work in real use.

What we’re building

A system that:

Receives a message
Generates a contextual AI response
Converts it into a cloned voice
Sends the audio back automatically

Use cases:

customer support automation
voice assistants
creator voice replies
agency workflows

Architecture

`Input (Webhook / App)
        ↓
AI Response (LLM)
        ↓
ElevenLabs (Text → Speech)
        ↓
Output (API / App / Messaging)`

Step 1 — Webhook (Input Layer)

In n8n:

Add a Webhook node
Enable POST requests

Example input:

`{
  "message": "Tell me about your service"
}`

Why webhook?

Because it allows:

app integrations
API triggers
scalable input

Step 2 — AI Response Layer

Add an AI node (OpenAI / OpenRouter).

Input:

`{{ $json.message }}`

System prompt (critical)

This is where most people mess up.

Bad:

long paragraphs
generic responses
no tone control

Good:

short replies
defined tone
controlled output

Example:

`You are a helpful assistant.

- Keep responses under 3 sentences
- Use natural conversational tone
- Avoid long explanations`

This directly affects voice quality later.

Step 3 — ElevenLabs Voice Generation

Use:

HTTP Request node
OR
dedicated integration
API structure (simplified):
POST https://api.elevenlabs.io/v1/text-to-speech/{voice_id}

`{
  "text": "{{ $json.output }}",
  "model_id": "eleven_multilingual_v2"
}`

Headers:

xi-api-key
content-type

Output:

audio stream / file

Step 4 — Output Layer

Options depend on use case:

return audio via API
send via WhatsApp / Telegram
attach in app
auto reply system

Example (basic API response):

`{
  "audio_url": "generated_audio.mp3"
}`

Full Workflow Logic

Webhook
→ AI Node
→ ElevenLabs
→ Response

What actually breaks (real issues)

Long AI responses = bad audio

Problem:

sounds robotic
unnatural pacing

Fix:

limit output length
enforce short responses

Latency issues

Flow delay:

AI response
voice generation

Result:

slow replies

Fix:

reduce token usage
optimize prompts
avoid unnecessary steps

Voice quality problems

Common issues:

inconsistent tone
unnatural pauses

Fix:

use clean training data
adjust ElevenLabs settings
test multiple voice configs

Cost scaling

You’re paying for:

AI tokens
voice generation

Bad setup:

long responses → higher cost

Good setup:

short + precise outputs
Important design insight

Most people think this is a “voice problem”.

It’s not.

It’s a text control problem.

If your text output is bad:
→ your voice output will be worse

Where this becomes powerful

Once stable, you can extend this to:

Multi-language voice bots
memory-based assistants
CRM integrations
lead qualification systems

Final thoughts

This workflow is simple on paper:

Text → AI → Voice → Output

But the quality depends entirely on:

how you control responses
how you handle latency
how you structure the flow

The difference between a demo and a usable system is in these details.

If you want the full breakdown check out - Build Voice Clone Bot : n8n + ElevenLabs Automation 2026

Question

Anyone here running voice-based automation in production?

Curious how you’re handling:

latency
scaling
real-time responses

Would love to compare setups 👇

Emergent AI Pricing Explained Credits, Plans & How Not to Waste Money

Jayanth — Fri, 24 Apr 2026 14:22:54 +0000

The credit problem nobody warns you about

If you're coming to Emergent from flat-rate tools — GitHub Copilot, Cursor, Replit's base tier — the pricing model will catch you off guard.
Emergent isn't $20/month = unlimited. It's $20/month = 100 credits. And credits are consumed every time the AI does work: generating a feature, debugging an error, refactoring a component, loading project context.
There's no upfront price list. No console that tells you "this prompt will cost 18 credits." You build, you spend, you find out at the end.

Here's the credit cost map I put together from actual usage:

`TASK                              CREDIT COST
─────────────────────────────────────────────
Landing page + contact form       10–20 credits
User authentication (OAuth)       25–40 credits
Multi-file debugging session      15–30 credits
Full styling refactor             30–50 credits
Stripe payment integration        35–60 credits`

The ranges exist because detailed prompts cost more than vague ones. "Add login" costs less than "Add login with Google OAuth, session management, error states, and post-auth redirect." Precision in your prompt = more computation = more credits.

Where credits actually disappear

Context loading scales with project size. Emergent reads your entire project before making changes — this is what enables it to modify multi-file logic correctly. But as your codebase grows, every action costs more because context is larger.

Debug loops are the silent budget drain. Identify bug → generate fix → test → secondary error → fix again. That's 30–50 credits per loop. Multiple loops on a complex bug can cost as much as building the original feature.

"Quick changes" aren't quick credit-wise. Asking for a small tweak on a large project still triggers full project context loading. There's no "lightweight mode."

The math that matters:

Standard breaks even with Pro at ~150 credits/month. Above that, Pro saves money per credit.
Team only makes sense for genuine multi-developer workflows. Solo builders pay ~$100/month for collaboration features they don't use.
Unused credits expire monthly. Don't over-subscribe. Start at Standard, track for 30 days, then decide.

The decision framework in code

`function pickEmergentPlan(monthlyCredits, teamSize) {
  if (teamSize >= 3) return "Team";
  if (monthlyCredits > 150) return "Pro";
  if (monthlyCredits > 0) return "Standard";
  return "Free (demo only)";
}

// Add 30% buffer for debugging
const estimatedCredits = featureCost * 1.3;
const plan = pickEmergentPlan(estimatedCredits, 1);`

Discount code

Before you pick a plan: ELEVORAS at checkout = 5% off Standard, Pro, and Team. Applies every billing cycle as long as your subscription is active. Cancel and resubscribe = need to re-enter.

vs. alternatives (developer perspective)
Replit: Better community, better for projects requiring real developer control. "Unlimited" throttles on heavy compute. Real cost at serious usage: $50+/month.

Bolt: No-credit flat rate is good for prototyping at volume. Lock-in is the problem — exporting a Bolt app to your own infra requires refactoring. Plan for that time cost.
Lovable: Superior reasoning for complex logic. $40/month for 200 credits. Worth it for production-grade apps where correctness matters more than speed.

Emergent's actual advantage for developers: Exported codebase is clean, readable, and deployable anywhere. No proprietary runtime. You own what you build.
Full breakdown + discount code at elevoras.com — link in bio.
Drop questions about specific use case credit costs below — happy to share the estimates.

Build a 24/7 Facebook Messenger AI Chatbot With n8n (Full Setup — No Code)

Jayanth — Wed, 22 Apr 2026 09:17:25 +0000

What this builds

A Facebook Messenger chatbot that responds to every incoming message automatically, 24/7, using an AI agent connected to your Facebook Business Page via n8n. Customers message your page — they receive an intelligent, context-aware reply within 30 seconds, whether you are online or not.

Workflow JSON download: Available on the blog

Architecture

`Facebook Messenger message received
        ↓
n8n Webhook (GET + POST — allow multiple HTTP methods)
        ↓
IF node — hub.mode = "subscribe" AND hub.verify_token = [your token]
  ├── TRUE → Respond to Webhook with hub.challenge (verification)
  └── FALSE → Extract message from POST body
        ↓
AI Agent node (OpenRouter)
  — reads sender ID + message text
  — generates contextual reply
        ↓
HTTP Request → Facebook Graph API
  POST /me/messages → send reply to sender`

Step 1 — Create your Facebook Developer App

Go to developers.facebook.com and create an account if you do not have one.
Click My Apps → Create App.

App configuration:

`App type:    Business
App name:    [Your Business] AI Assistant
Portfolio:   Select yours, or "No business portfolio selected"`

Important: Do not overthink the naming. You can modify everything later.

Step 2 — Switch app to Live mode (most tutorials skip this)

Your app starts in Development mode — only you can test it. Real customers cannot interact with it until you switch to Live.
Before switching, you need a Privacy Policy URL. Facebook verifies this automatically.
Fastest method: go to termsfeed.com → generate a free privacy policy → copy the URL.
In your app settings:

Find "Privacy Policy URL" field → paste your URL
Toggle the mode switch at the top from Development to Live

Without this step, your chatbot will only work when you are testing it yourself. All live customer interactions will fail silently.

Step 3 — Create the n8n webhook

Open your n8n dashboard → New Workflow → add a Webhook trigger node.
Critical settings in the webhook configuration:

`Allow Multiple HTTP Methods: ON  ← most people miss this
HTTP Method:                 GET and POST both selected
Respond:                     Using 'Respond to Webhook' Node`

The "Allow Multiple HTTP Methods" toggle is the setting that allows Facebook's verification handshake (GET request) and actual message delivery (POST request) to both hit the same webhook endpoint. Without this, you need two separate webhooks — and the verification fails.
Copy the Production URL from the webhook node. This is what you paste into Facebook next.

Step 4 — Add Messenger to your Facebook App

Back in your Facebook Developer dashboard:

Find the Products section → click Add Product
Find Messenger → click Set up

Inside the Messenger configuration:
Webhook settings:

`Callback URL:   [paste your n8n Production URL]
Verify Token:   AI-chatbot  (or any string you choose — you will need this exactly in Step 5)`

Click Verify and Save. Facebook sends a GET request to your webhook to confirm it is reachable.
Subscribe to message events:

`messages:        ON
message_reads:   ON`

Generate a Page Access Token:

Select your Business Page from the dropdown
Click Generate Token
Copy the token immediately — it only displays once
Store it securely — you need it in Step 7 to send messages back

Subscribe your page to the webhook by clicking Add Subscriptions next to your page name.

Step 5 — The verification handshake (where 90% of people get stuck)

Facebook verifies your webhook by sending a GET request with three query parameters:

`hub.mode          = "subscribe"
hub.verify_token  = [the token you set in Facebook]
hub.challenge     = [a random string Facebook wants echoed back]`

Your n8n workflow must respond with the exact value of hub.challenge. If it does not, Facebook rejects the webhook and nothing works.
Add an IF node after the webhook:

`Condition 1: {{ $json.query['hub.mode'] }}         equals  subscribe
Condition 2: {{ $json.query['hub.verify_token'] }}  equals  AI-chatbot
Both conditions must be TRUE`

On the TRUE branch — add a "Respond to Webhook" node:

`Respond with:  Text
Response body: [switch from Fixed to Expression]
Expression:    {{ $json.query['hub.challenge'] }}`

This echoes the challenge string back to Facebook, completing verification. Until this works, nothing else in the workflow can run.
Test it: Save the workflow, click Execute Workflow, then go back to Facebook and click Verify and Save on the webhook configuration. If verification fails, check that your IF conditions exactly match the parameters Facebook sends.

Step 6 — Extract the message from POST requests

When a customer sends a message, Facebook sends a POST request to your webhook with a JSON body. The message is nested inside:

`// Facebook Messenger webhook POST body structure
{
  "entry": [{
    "messaging": [{
      "sender": { "id": "SENDER_PAGE_SCOPED_ID" },
      "recipient": { "id": "YOUR_PAGE_ID" },
      "timestamp": 1234567890,
      "message": {
        "mid": "message_id",
        "text": "Hello, is this available?"
      }
    }]
  }]
}`

On the FALSE branch of your IF node (POST requests that are not verification), add a Set Fields node to extract what you need:

sender_id:    {{ $json.body.entry[0].messaging[0].sender.id }}
message_text: {{ $json.body.entry[0].messaging[0].message.text }}

These two fields feed into the AI agent.

Step 7 — AI Agent node

Add an AI Agent node. Connect OpenRouter credentials.

`Input:        {{ $json.message_text }}`

System prompt — paste this:

`You are a helpful customer service assistant for [Your Business Name].

You respond to Facebook Messenger messages from potential customers 
and existing clients.

Your tone: friendly, professional, helpful. Never robotic.

Key information about our business:
[Add: what you sell, your pricing if public, your hours, 
your location, your main services — whatever customers typically ask about]

If you cannot answer a specific question, tell the customer:
"I'll make sure [Name] gets back to you on this personally — 
usually within a few hours during business hours."

Never make up information you are not sure about.
Keep replies concise — 2-4 sentences maximum.`

Customise the system prompt for your specific business. The more specific the business information, the more useful the responses. Add your FAQs, your pricing tier (if public), your response time commitments, and any questions you regularly receive.

Step 8 — Send the reply via Facebook Graph API

`json
Add an HTTP Request node.

Method: POST
URL: https://graph.facebook.com/v18.0/me/messages
Headers:
Authorization: Bearer [YOUR_PAGE_ACCESS_TOKEN]
Content-Type: application/json

Body (JSON):
{
"recipient": {
"id": "{{ $('Set Fields').first().json.sender_id }}"
},
"message": {
"text": "{{ $json.output }}"
}
}

`
`

Replace [YOUR_PAGE_ACCESS_TOKEN] with the token you generated in Step 4.
The sender_id targets the reply to the specific person who sent the message. The $json.output contains the AI agent's response.

Step 9 — Activate and test

Toggle the workflow Active (top right — turns blue).
Open your Facebook Business Page. Send a message to your own page from a personal Facebook account. Wait 15–30 seconds. You should receive an AI-generated reply.
If no reply arrives, check the Executions tab in n8n. Each execution log shows exactly which node completed and where the flow stopped.

What breaks

Facebook verification fails repeatedly: Your IF node conditions are not matching Facebook's query parameters exactly. The parameters are case-sensitive: hub.mode and hub.verify_token with dots, not underscores. Also check that your Respond to Webhook node is on the TRUE branch, not the FALSE branch.

Messages arrive but no reply is sent: The Page Access Token has expired or is invalid. Facebook page tokens can expire — regenerate it from the Facebook Developer dashboard and update the HTTP Request node. Also confirm the token has pages_messaging permission.

AI Agent responds but Graph API returns 403: Your app does not have the pages_messaging permission enabled. Go to App Settings → Permissions and Features → search pages_messaging → Request permission.
Workflow triggers on your own page posts, not just messages: You subscribed to more events than needed. In Facebook Messenger webhook settings, ensure only messages and message_reads are enabled. Disable feed, comments, and other event types.

n8n receives POST but entry[0].messaging is undefined: Facebook occasionally sends other webhook event types (delivery receipts, echo messages). Add a second IF condition before the AI agent: check that $json.body.entry[0].messaging[0].message.text exists and is not null.

Running cost

OpenRouter with GPT-4 mini: approximately $0.001 per message response. 1,000 customer messages per month costs about $1.00 in API credits.
n8n: free self-hosted or free cloud trial.
Facebook API: free.

The entire chatbot infrastructure costs under $7/month for most small businesses — significantly less than a single missed client.
Workflow JSON at elevoras.com. Import directly into n8n and update the Page Access Token and verify token to your own values.

Building a variation with memory (tracking conversation history per user)? Drop it in the comments — that is the natural next step and happy to share the memory node setup.

Automate Personalized Cold Email Icebreakers With n8n, 0.3% to 10% Reply Rate

Jayanth — Tue, 21 Apr 2026 09:43:30 +0000

What this builds

An n8n workflow that takes a list of prospects from Google Sheets, scrapes each prospect's website (homepage plus up to 3 internal pages), uses AI to extract meaningful business insights from each page, generates a hyper-personalised multi-line icebreaker for each prospect, and writes the icebreaker back to the Sheet — ready for your outreach tool.

Output example:

`"Hey Katie, love how KTL Graphics makes it easy to filter by acreage — 
also a fan of your property update email option. Wanted to run 
something by you..."`

The system found acreage filtering and email notification features by actually crawling the website — not from the company name or LinkedIn headline.

Workflow JSON download: Available on the blog

Architecture

`Manual Trigger
        ↓
Google Sheets — get all rows
        ↓
Filter — only rows with email AND website URL
        ↓
Loop Over Items (batch size 1)
        ↓
HTTP Request — scrape homepage (HTML)
        ↓
Edit Fields — extract html field
        ↓
Code node — convert to string
        ↓
HTML Extractor — pull all <a href> links
        ↓
Edit Fields — keep: first_name, last_name, email, website_url, links
        ↓
Split Out — one row per link
        ↓
Filter — links starting with /
        ↓
Code node — normalise relative/absolute URLs
        ↓
Remove Duplicates + Limit (max 3 pages)
        ↓
HTTP Request — fetch each internal page
        ↓
HTML to Markdown conversion
        ↓
AI Agent — summarise each page into abstract
        ↓
Merge all abstracts
        ↓
AI Agent — generate icebreaker from all abstracts
        ↓
Google Sheets — write icebreaker back to prospect row`

Step 1 — Google Sheets setup

Export your Apollo.io leads (or any source) to Google Sheets.

Required columns:

`first_name | last_name | email | website_url | icebreaker (empty, filled by workflow)`

The workflow reads from this sheet and writes icebreakers back to the icebreaker column.

Step 2 — Filter node (quality gate)

Add a Filter node after the Sheets Get Rows node.
Two conditions, both must be true:

`Condition 1: website_url  exists and is not empty
Condition 2: email        exists and is not empty`

Without this filter, the workflow attempts to scrape blank URLs and throws errors that cascade through the rest of the pipeline.

Step 3 — Loop Over Items (batch size 1)

Add a Loop Over Items node.

Batch Size: 1

This processes one prospect at a time. Without it, the workflow tries to process all prospects simultaneously — rate limits on external sites cause failures, and the AI responses get mixed across prospects.

Step 4 — Scrape the homepage

Add an HTTP Request node.

`Method:      GET
URL:         {{ $json.website_url }}
Error handling: Continue on error
Redirects:   Follow, max 21`

"Continue on error" is critical. Some websites block scraping. Without this setting, one blocked site kills the entire workflow run.

Step 5 — Extract and normalise HTML

Add an Edit Fields node:

Field: html → string → {{ $json.data }}

Add a Code node:

`return [{
  json: {
    html: $json.html.toString()
  }
}];`

This converts the raw response body to a usable string

Step 6 — Extract all links from the homepage

Add an HTML Extractor node.

`CSS Selector:  a
Attribute:     href
Return:        Array
Options:       Trim values + clean text`

This pulls every link from the homepage — navigation, footer, internal pages. The homepage alone contains only part of the story. The About page, Services page, and Blog posts are where the personalisation gold lives.

Step 7 — Normalise URLs (Code node)

After splitting links into individual rows and filtering for links starting with /, add this Code node to normalise both relative and absolute URLs to relative paths:

`const items = $input.all();

const updatedItems = items.map((item) => {
  const link = item?.json?.links;

  if (typeof link === "string") {
    if (link.startsWith("/")) {
      item.json.links = link;
    }
    else if (link.startsWith("http://") || link.startsWith("https://")) {
      try {
        const url = new URL(link);
        let path = url.pathname;
        if (path !== "/" && path.endsWith("/")) {
          path = path.slice(0, -1);
        }
        item.json.links = path || "/";
      } catch (e) {
        item.json.links = link;
      }
    }
    else {
      item.json.links = link;
    }
  }
  return item;
});

return updatedItems;`

Why this is necessary: Websites use both relative links (/about) and absolute links (https://example.com/about). You need both normalised to the same format to deduplicate and combine with the base URL correctly in the next step.

Step 8 — Deduplicate and limit

Add a Remove Duplicates node (deduplicate on links field) followed by a Limit node:

`Max items: 3
Keep:      First Items`

Three pages per prospect is the sweet spot. Enough to find specific details, not enough to run up excessive API costs or hit rate limits on the target site.

Step 9 — Fetch internal pages

Add another HTTP Request node to fetch each filtered internal URL:

Method: GET
URL: {{ $json.website_url }}{{ $json.links }}
Error handling: Continue on error
`

The URL concatenates the base domain from the original lead data with the relative path extracted from the link list.

Step 10 — HTML to Markdown

Add an HTML to Markdown node:

`Mode:            HTML to Markdown
HTML:            {{ $json.data ? $json.data : "<div>empty</div>" }}
Destination Key: data`

Markdown is significantly more token-efficient than HTML for AI processing. Stripping HTML tags reduces the content you are passing to the AI model by 60–80%, which directly reduces API cost and improves the quality of the AI's analysis by removing noise.

Step 11 — AI page summariser

Add an AI Agent node with this system prompt:

You are a helpful, intelligent website scraping assistant.

You are provided a Markdown scrape of a website page.
Your task is to provide a two-paragraph abstract of what this page is about.

Return in this JSON format:
{"abstract":"your abstract goes here"}

Rules:

Your extract should be comprehensive — similar level of detail as an abstract to a published paper.
Use a straightforward, factual writing style.
Focus on what is unique or distinctive about this business or page.
Note any specific features, products, services, or differentiators that would be useful for personalised outreach.
Return ONLY the JSON object. No backticks. No explanation.

Model: GPT-4 mini via OpenRouter — approximately $0.0003 per page abstract.

Step 12 — Merge all abstracts

After the loop processes all three pages, merge the abstract outputs into a single node. Use a Merge node set to "Combine All Items."
Pass the merged abstracts to the final AI Agent.

Step 13 — Icebreaker generator

Add a final AI Agent node with this system prompt:

`You are an expert cold email copywriter specializing in personalized outreach.

You will receive multiple website page summaries for a prospect company.
Your task is to write a multi-line, personalized icebreaker for a cold email.

Rules:
- Reference 1-2 SPECIFIC details you found on their website
  (features, initiatives, content, language they use about themselves)
- Sound like you actually explored the website — not like you read a summary
- Be conversational, warm, and curious — not salesy
- Keep it to 2-3 sentences maximum
- Address the first_name directly at the start
- End with a natural transition into your pitch ("Wanted to run something by you...")

First name: {{ $('Loop Over Items').first().json.first_name }}
Website summaries: [all abstract outputs concatenated here]

Return ONLY the icebreaker text. No JSON. No explanation.
`

Step 14 — Write back to Google Sheets

Add a Google Sheets node:

`Operation:    Update Row
Match on:     email = {{ $json.email }}
Update:
  icebreaker: {{ $json.icebreaker }}`

The icebreaker column fills in for each row as the workflow processes it. When the run is complete, your Sheet has a personalised icebreaker for every prospect with a valid website URL.

What breaks

HTTP Request returns 403 on most sites: The site is blocking the default n8n user agent. Add a custom header: User-Agent: Mozilla/5.0 (compatible; outreach-research/1.0). This passes most basic anti-scraping checks.
AI Agent returns a JSON error instead of abstract: The page content was empty (HTTP request returned an error page). The {{ $json.data ? $json.data : "

empty" }} expression in the HTML to Markdown node handles this — it passes a dummy div instead of null, which prevents the AI from throwing on empty input.

Loop produces mixed data across prospects: You are not using batch size 1. Set Loop Over Items batch size to exactly 1.
Icebreakers sound generic despite the workflow running: The AI is receiving summaries but not finding distinctive details. Check your Limit node — if it is set to 0 or is missing, you may only be scraping the homepage. Set it to 3 to ensure About and Services pages are included.

Running cost

OpenRouter GPT-4 mini: approximately $0.002 per prospect (3 page abstracts + 1 icebreaker generation).
100 prospects = $0.20 in API costs.
1,000 prospects = $2.00.

Compare this to $5–$50 per manually researched and written personalised opener. The cost case is immediate.
Workflow JSON at elevoras.com.
What niche are you targeting with cold outreach? Drop it in the comments — happy to suggest prompt adjustments for specific industries.

Build an AI Newsletter Agent That Reads the Web Every Morning (n8n + OpenRouter + Gemini)

Jayanth — Sun, 19 Apr 2026 17:44:56 +0000

What this builds

An automated AI newsletter agent that runs every night at midnight, searches the web for the most relevant news in your chosen niche, formats it into a professional HTML newsletter, emails it to you automatically, and logs every story to Google Sheets to prevent duplicates in future runs.

You wake up to fresh, relevant, personalised industry news. No manual research. No subscriptions to dozens of sources. No duplicate stories.

Architecture

Schedule Trigger (midnight daily)
        ↓
AI Agent (OpenRouter — GPT-4 via OpenRouter)
  Tools attached:
  ├── Google Gemini (live web search — past week)
  └── Think tool (internal quality check)
  Output: structured JSON with subject + 3 news items
        ↓
Gmail — send formatted HTML newsletter
        ↓
Code node — unbundle 3 items into individual rows
        ↓
Google Sheets — log each story (duplicate prevention)

## Step 1 — Schedule Trigger

Add a Schedule Trigger node. Set it to fire at midnight daily.

Trigger interval: Days
Days between:     1
Hour:             0 (midnight)
Minute:           0

## Step 2 — AI Agent node

Add an AI Agent node. Rename it News Research Agent.
Connect OpenRouter Chat Model. Toggle "Require Specific Output Format" to ON.

User prompt:

Send me the newsletter for today.

System prompt:

You are an expert newsletter curator specializing in AI tool launches 
and industry developments. Your mission is to research the internet 
and create a daily newsletter summarizing the 3 most impactful AI 
tool launches or developments from the past week.

ROLE: AI Industry Newsletter Curator
OUTPUT COUNT: Exactly 3 news items
CHARACTER LIMIT: 150 words per news item maximum

**GUIDELINES:**
- Focus on NEW tool launches, significant updates, or industry-changing developments
- Prioritize tools that solve real business problems
- Include why each development matters to professionals
- Verify information from multiple sources when possible
- Maintain an engaging, professional tone

STRUCTURE: Provide your response in the following JSON format:
{
  "subject_line": "AI Weekly: [Key Theme] - [Date]",
  "news_items": [
    {
      "title": "Tool/Development Name",
      "content": "Brief description and key features",
      "why_it_matters": "Impact explanation for professionals",
      "source": "Primary source URL",
      "category": "Tool Launch/Update/Industry News"
    }
  ]
}

TOOLS AVAILABLE: You have access to internet search, thinking 
capabilities, and a Google Sheets log to avoid duplicate content.

AVOID:
- Outdated news (older than 1 week)
- Overly technical jargon without explanation
- Duplicate content from previous newsletters
- Speculation or unverified rumors

Step 3 — Add the Gemini search tool

Click the Tools tab inside the AI Agent node. Add Google Gemini as a tool.

Model:          gemini-1.5-flash
Search recency: Past week

Step 4 — Add the Think tool

Click Tools again. Add the Think tool. Paste this description:

Use the tool to think about something. It will not obtain new information 
or change the database, but just append the thought to the log. Use it 
when complex reasoning or some cache memory is needed.

Step 5 — Structured Output Parser

Configure with this JSON schema:

{
  "subject_line": "AI Weekly Update - March 15, 2024",
  "news_items": [
    {
      "title": "Revolutionary AI Tool Launch",
      "content": "Description of the tool and its capabilities.",
      "why_it_matters": "Impact on industry professionals.",
      "source": "https://example.com",
      "category": "Tool Launch"
    }
  ]
}

Select Google Gemini Chat Model as the model for the parser. Model: gemini-1.5-flash.

Step 6 — Gmail node

Operation:  Send Message
To:         your@email.com
Subject:    {{ $json.output.subject_line }}
Email type: HTML

Message body (Expression mode):

<div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
  <h1 style="color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px;">
    {{ $json.output.subject_line }}
  </h1>

  {{ $json.output.news_items.map(item => `
  <div style="margin: 25px 0; padding: 20px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #3498db;">
    <h2 style="color: #2c3e50; margin-top: 0;">${item.title}</h2>
    <span style="background: #3498db; color: white; padding: 3px 10px; border-radius: 12px; font-size: 12px;">${item.category}</span>
    <p style="color: #444; line-height: 1.6; margin-top: 12px;">${item.content}</p>
    <div style="background: #e8f4fd; padding: 12px; border-radius: 6px; margin-top: 12px;">
      <strong style="color: #2980b9;">Why it matters:</strong>
      <p style="color: #444; margin: 5px 0 0 0;">${item.why_it_matters}</p>
    </div>
    <a href="${item.source}" style="color: #3498db; text-decoration: none; font-size: 13px;">Read source →</a>
  </div>
  `).join('') }}

  <p style="color: #888; font-size: 12px; text-align: center; margin-top: 30px;">
    Generated by your AI newsletter agent · {{ new Date().toLocaleDateString() }}
  </p>
</div>

Step 7 — Code node (unbundle)

const items = [];

const data = $('News Research Agent').first().json.output;
const subjectLine = data.subject_line || '';
const newsList = data.news_items || [];

for (const news of newsList) {
  items.push({
    json: {
      subject_line: subjectLine,
      title: news.title || '',
      content: news.content || '',
      source: news.source || '',
      category: news.category || '',
      date_logged: new Date().toISOString().split('T')[0]
    }
  });
}

return items;

Step 8 — Google Sheets logging

Operation:  Append Row
Columns:
  subject_line: {{ $json.subject_line }}
  title:        {{ $json.title }}
  content:      {{ $json.content }}
  source:       {{ $json.source }}
  category:     {{ $json.category }}
  date_logged:  {{ $json.date_logged }}

What breaks

Agent fabricates news instead of searching: Gemini tool is not connected. Check the Tools tab — Gemini should show a green connection indicator.

Structured Output Parser fails: Add this to your system prompt: "Return ONLY valid JSON. No markdown, no backticks, no explanation before or after the JSON object."

Code node throws undefined error: The node name in $('News Research Agent') does not match your actual node name. Case sensitive, space sensitive.

Gmail subject shows raw expression: Switch from Fixed to Expression mode in the subject field.

Workflow JSON available at elevoras.com. Import into n8n, connect your credentials, and activate.

What niche are you building this for? Drop it in the comments.

N8N Workflow — Product Photo to Marketing Video, Automatically (Runway ML + OpenRouter)

Jayanth — Sat, 18 Apr 2026 07:44:06 +0000

What this builds

A fully automated product marketing pipeline. You submit a product photo, title, and description through a form.

The workflow:

`1. Uploads the original image to Google Drive for storage

Sends product details to an AI agent (OpenRouter) which generates a professional photography prompt
Downloads the image as binary from Google Drive
Uploads it to ImageBB to create a public URL
Sends the public image URL + a video generation prompt to Runway ML gen-4-turbo
Polls the render status until the video is complete
Emails the customer the finished image URL and video link automatically`

Input: a basic product photo + title + description.

**Output: **a professional marketing video delivered to their inbox in under 15 minutes.

**Cost per video: **roughly $0.25 (Runway ML charge) plus minimal OpenRouter usage.

Architecture

`n8n Form Trigger (photo + title + description + email)
        ↓
Google Drive — upload original image (binary)
        ↓
AI Agent (OpenRouter) — generate professional photography prompt
        ↓
Google Drive — download image as binary
        ↓
HTTP Request → ImageBB API — upload image, get public URL
        ↓
HTTP Request → Runway ML API — image_to_video (gen-4-turbo)
        ↓
Wait 60s → HTTP GET → check task status → IF running → wait 5s → loop
        ↓ [loop until SUCCEEDED]
Gmail — send email with image URL + video URL`

Step 1 — Form Trigger

Add an n8n Form Trigger node. Configure four fields:
Field 1 — Product Photo
Type: File upload
Required: Yes
Multiple: No
Name: product photo

Field 2 — Product Title
Type: Text
Required: Yes
Placeholder: your product name
Name: product title

Field 3 — Product Description
Type: Text
Required: Yes
Name: product description

Field 4 — Email Address
Type: Email
Required: Yes
Placeholder: name@example.com
Name: email

Form title: "Go to Market" — this becomes a client-facing intake form if you share the Production URL.
Click Execute Node to generate your form. Pin the test data after submitting once — this saves you re-filling the form at every subsequent node test.

Step 2 — Upload to Google Drive

Add a Google Drive node.
Operation: Upload File
File: {{ $('Form Trigger').first().binary['product photo'] }}
File name: {{ $('Form Trigger').first().json['product title'] }} (original)
Folder: product creatives
Create the "product creatives" folder in your Google Drive before connecting. The dynamic file naming means each upload is labelled with the product name so your Drive does not become a folder of unnamed files.

Step 3 — AI Agent (generate the photography prompt)

Add an AI Agent node. Connect OpenRouter credentials.
The raw product description from a form submission does not make a good image generation prompt. This node transforms it into professional photography language that Runway ML can use.
System prompt:
You are a world-class marketing strategist and expert text-to-image prompt engineer
specializing in hyper-realistic product photography prompts for AI image generation.

When given a product description, craft a detailed professional prompt that produces:

`- Hyper-realistic studio photography

Clean minimalistic aesthetic
Product as main subject with sharp detail and perfect lighting
Complementary background (soft gradient, light-colored, or pure white)
Professional lighting: softbox, studio lights, or natural soft shadows
High-end premium feel`

Output Format:

Write a single text-to-image prompt ready for direct input into an AI model.
Be direct and descriptive. No unnecessary repetition.

User message:

Product: {{ $('Form Trigger').first().json['product title'] }}
Description: {{ $('Form Trigger').first().json['product description'] }}
The agent output is the photography prompt string. Save it — you do not actually send it to an image generator in this workflow (Runway handles that). You will use it as context for the video generation prompt in Step 6.

Step 4 — Download from Google Drive (as binary)

Add a second Google Drive node.

Operation: Download File
By: ID
File ID: {{ $('Upload to Google Drive').first().json.id }}
This converts the stored file back into binary data that can be processed by external APIs. You cannot send a Google Drive link to ImageBB — you need the actual binary.

Step 5 — Upload to ImageBB (create public URL)

Add an HTTP Request node.
Method: POST
URL: https://api.imgbb.com/1/upload?key=[YOUR_IMGBB_API_KEY]
Body type: Form Data
Fields:
image: [binary data from previous Google Drive node]
Get your free API key from imgbb.com → your account dashboard → API.
ImageBB returns a JSON response with multiple URL formats. Use data.url — the direct image URL without any HTML wrapping. This is what Runway ML requires.
javascript// The field you need from the response:
{{ $json.data.url }}

Step 6 — Generate video with Runway ML

Add an HTTP Request node.
Method: POST
URL: https://api.dev.runwayml.com/v1/image_to_video
Headers:
Authorization: Bearer [YOUR_RUNWAY_API_KEY]
x-runway-version: 2024-11-06
Content-Type: application/json

Body (JSON):

`{
  "model": "gen4_turbo",
  "promptImage": "{{ $('ImageBB Upload').first().json.data.url }}",
  "promptText": "Create a highly professional marketing video from the provided product photo. Simulate a smooth, realistic product rotation — slowly turning in place. Movement should be continuous, slow, and elegant — no sudden pans, jerks, or cuts. Always keep the entire product fully in frame, centered, and clearly visible. Avoid zooming in or cropping. Focus on a premium, clean, modern aesthetic suitable for commercial marketing. No flashy effects, transitions, or overlays.",
  "duration": 10,
  "ratio": "960:960"
}`

Duration note: 10 seconds costs approximately $0.50 in Runway ML credits. 5 seconds costs approximately $0.25. For product demos, 10 seconds gives the rotation enough time to feel complete. For social media ads where shorter is better, use 5 seconds.
Ratio note: 960:960 (square) works across all platforms. If your client specifically needs 9:16 vertical for Reels/Shorts, change to "ratio": "720:1280".
The API returns a task_id immediately — the video is queued, not rendered.

Step 7 — Polling loop (wait for render)

Video generation with Runway ML takes 60–180 seconds. Build a polling loop.

Add a Wait node:

Wait: 60 seconds
Add an HTTP Request node to check status:
Method: GET
URL: https://api.dev.runwayml.com/v1/tasks/{{ $('Runway Generate').first().json.id }}
Headers:
Authorization: Bearer [YOUR_RUNWAY_API_KEY]
x-runway-version: 2024-11-06
Add an IF node:
Condition: {{ $json.status }} equals "RUNNING"
True → Wait 5 seconds → loop back to status check
False → continue to Gmail

When status equals "SUCCEEDED", the response includes an output array. The first element — output[0] — is the direct video URL.
If status equals "FAILED", add an error branch that sends an email notifying the client of the failure.

Step 8 — Send the email

Add a Gmail node. Connect via OAuth in n8n credentials.
To: {{ $('Form Trigger').first().json['email'] }}
Subject: Marketing Materials: {{ $('Form Trigger').first().json['product title'] }}
Type: HTML
Body:

`html<p>Hey,</p>

<p>Your marketing materials for <strong>{{ $('Form Trigger').first().json['product title'] }}</strong> are ready.</p>

<p><strong>Enhanced product image:</strong><br>
<a href="{{ $('ImageBB Upload').first().json.data.url }}">View image →</a></p>

<p><strong>Marketing video:</strong><br>
<a href="{{ $('Runway Status Check').first().json.output[0] }}">View video →</a></p>

<p>Both files are ready to download and use in your ads immediately.</p>

<p>Cheers,<br>
[Your name]</p>`

What breaks

Runway ML returns 401: Your API key is wrong or your x-runway-version header is outdated. Check the current version string in Runway's API documentation — it updates periodically.
ImageBB returns 400: The image file is too large (ImageBB free tier has a 32MB limit) or the binary data is not being passed correctly. Verify the Google Drive download node is outputting binary data, not a file reference.

Status check loop never exits: Add a counter variable and a maximum iteration count (15 attempts). If the loop runs 15 times without a "SUCCEEDED" status, break to an error email. Runway rarely takes longer than 3 minutes — if it does, the task has likely failed silently.
Gmail authentication fails: Re-authorise the Gmail OAuth credential in n8n. Google OAuth tokens expire and need periodic refresh.

Extending this workflow

For agencies serving multiple clients, replace the Form Trigger with a webhook and build a simple intake page that clients access directly. Their submission triggers the workflow and they receive the video by email without any manual step from you.
For ecommerce stores with product catalogues, connect a Google Sheets trigger that iterates through product rows and generates a video for each SKU in batch mode.

The workflow JSON is at elevoras.com. Import directly into n8n and add your API keys.

What are you using this for? Drop your use case in the comments.

N8N on WebspaceKit — Unlimited Automations for $6/Month, Zero Terminal Required

Jayanth — Fri, 17 Apr 2026 17:26:57 +0000

ARTICLE BODY:

What this solves

n8n Cloud's Starter plan costs $20/month and caps your workflow executions. Build serious automations — daily triggers, webhook listeners, AI API calls — and you hit that cap within days.
Self-hosting removes the cap. But the usual path requires Docker setup, SSL configuration, reverse proxy management, and ongoing server administration. Most people look at that list and go back to the cloud plan.
WebspaceKit's managed n8n hosting is the third path: you get self-hosted pricing and unlimited executions, with zero server administration. The entire setup runs in under five minutes. No command line. No Docker.

Step 1 — Navigate to the n8n hosting page

Go to webspacekit.com/n8n-cloud-hosting/ and scroll down to the pricing section. Click "Choose Plan."
You will see billing period options: monthly, 12 months, and 24 months. The longer the commitment, the lower the monthly rate. For testing: 12 months. For production business automations you are already committed to: 24 months for the lowest per-month rate.

Step 2 — Create your account and complete payment

Fill in your name, email, and billing details. This is your WebspaceKit account — different from the n8n login you will create in Step 5.
Once payment completes, you are taken to your client area dashboard.

Step 3 — Find your n8n service

In the client area, your active services appear in a list. Click on your n8n hosting service. Look for the "Go to Setup" button and click it.
This opens the n8n initialisation page — a simple form with three fields.

Step 4 — Configure your n8n instance

Three fields:

`Owner First Name:  your first name
Owner Email:       your n8n login email
Owner Password:    strong password for your n8n dashboard`

Important: the Owner Email and Password here are your n8n login credentials — separate from your WebspaceKit account credentials. Use different passwords for each.
Click "Next" or "Complete Setup."

WebspaceKit provisions your instance. This takes 30–60 seconds. When the success screen appears, you will see your n8n dashboard URL:
https://your-instance.webspacekit.com
Click it. Your n8n instance opens.

Step 5 — First login and orientation

Log in with the email and password you set in Step 4.
Your dashboard loads with whatever starting template came with your plan. If you are on a plan that includes pre-built workflow templates, you will see those immediately in your workflows list.

The main panels:

`Workflows     — your automation canvas list
Credentials   — OAuth connections to your apps
Executions    — logs of every workflow run
Settings      — n8n configuration and user management`

Step 6 — Connect your first app

Every app n8n connects to requires a credential. For Gmail:

Settings → Credentials → New Credential → search "Google"
Select "Google OAuth2 API"
Follow the Google authorisation flow
Save the credential

That credential is now available to every Gmail node in every workflow you build. You authenticate once per service, not once per workflow.
Common credential types to set up immediately:

`Google (OAuth) — Gmail, Google Sheets, Google Drive
Notion (API key) — databases, pages
Slack (OAuth) — messages, channels
HTTP Request (no auth) — public APIs

Step 7 — Build your first workflow

Click "New Workflow" → drag a Schedule Trigger onto the canvas.
A minimal daily briefing workflow to start:

Node 1: Schedule Trigger
Mode: Days
Hour: 8
Minute: 0

Node 2: HTTP Request
Method: GET
URL: https://hacker-news.firebaseio.com/v0/topstories.json?limitToFirst=5&orderBy="$key"

Node 3: Gmail — Send Message
To: your@email.com
Subject: Morning Briefing — {{ $now.toLocaleDateString() }}
Body: {{ JSON.stringify($json, null, 2) }}plaintext

Wire them in sequence. Click "Execute Workflow" to test. Check your inbox.

That is the pattern. Every workflow in n8n follows the same structure: trigger → action(s) → optional logic nodes.
The workflows that actually save the most time

Three high-ROI starting points based on usage patterns:

Lead capture from form submissions → CRM:
Webhook Trigger → HTTP Request (validate data) →
Notion (create page in leads database) →
Gmail (send confirmation email)
Daily social content scheduler:
Schedule Trigger (9 AM) →
Google Sheets (read next queued post) →
HTTP Request (post to Twitter/X API) →
Google Sheets (mark row as posted)
Automatic invoice processing:
Gmail Trigger (attachment received) →
Extract attachments →
Google Drive (save to invoices folder) →
Notion (log invoice details)
Each of these replaces 15–30 minutes of daily manual work. At three workflows running daily, you recover roughly an hour per day within the first week.

What tends to break on first setup

Google OAuth redirect error: add your WebspaceKit n8n instance URL to the list of authorised redirect URIs in your Google Cloud Console OAuth app settings. Takes two minutes.

Workflow triggers but produces no visible output: check the Executions tab. Every execution is logged with full node-by-node data showing exactly what passed between nodes and where execution stopped.
Schedule Trigger not firing: confirm the workflow is Active (toggle in top right of the workflow editor, turns blue when active). A workflow in Test mode only fires when you manually trigger it from the editor.
Webhook URL not receiving data: WebspaceKit assigns you a fixed subdomain. Confirm the webhook URL in your n8n Form Trigger matches what you have registered in the external service.

Scaling up

Once the basic setup is running cleanly, the natural next steps:
Add error handling to critical workflows. An Error Trigger node catches any workflow failure and sends you a notification. For workflows that touch client data or financial systems, this is not optional.
Error Trigger → Gmail (send failure alert with error details)
Build a workflow template library. Export your best workflows as JSON (top menu → Download) and keep them in a folder. When you build for a new use case, start from the closest matching template rather than from scratch.

Connect n8n to your AI workflows. The HTTP Request node handles any API call — including OpenAI, Anthropic, or any LLM provider. This is how you build the kind of AI-powered automations covered elsewhere on this blog (news-to-WordPress, Instagram comment response, video generation pipelines) without needing a separate orchestration layer.

Full setup guide with every screenshot at elevoras.com.
Automating something interesting on WebspaceKit or running into a node configuration issue? Drop it in the comments.

N8N Workflow That Auto-Creates Viral YouTube Shorts While You Sleep

Jayanth — Wed, 15 Apr 2026 14:07:07 +0000

What this builds

A fully automated faceless YouTube Shorts pipeline. You add a topic. The workflow:

Reads your topic from Google Sheets Generates a short-form script optimised for vertical video (GPT-4 via OpenRouter) Creates AI image prompts for each scene Sends structured content to JSON2Video for vertical video rendering Polls render status until complete Downloads the MP4 Uploads directly to YouTube as a Short Updates your Sheet with the video URL

Target output: 60-second vertical Shorts, fully faceless, 9:16 format, rendered and uploaded without any manual steps.
Architecture

Schedule Trigger (daily or on-demand)
        ↓
Google Sheets — read first "to-do" row
        ↓
Script Agent — GPT-4 generates hook + body + CTA + scene image prompts
        ↓
JSON2Video API — POST with vertical template → returns project_id
        ↓
Wait 90s → GET render status → Switch (done / running / error)
        ↓ [loop until done]
HTTP Request — download MP4 as binary file
        ↓
YouTube node — upload as Short (9:16, under 60s)
        ↓
Google Sheets — update status + video URL

Step 1 — Google Sheet setup

Step 2 — Google Sheets node

Add a Google Sheets node as your trigger.
Operation: Get Rows
Filter: Script Status = "to-do"
Limit: 1 (first matching row only)
Critical: toggle "Return only first matching row" ON. Without this, the workflow attempts to process your entire backlog in one run — GPU costs spiral and the workflow times out.

Step 3 — Script Agent (GPT-4 via OpenRouter)

This is the node that determines whether your Short will perform or get skipped. The script structure for Shorts is different from long-form — hooks must be under 3 seconds of spoken word, and every scene needs to visually match the spoken content.
Add an AI Agent node. Connect OpenRouter credentials.
System prompt:
You are an expert YouTube Shorts scriptwriter.
You write addictive, fast-paced scripts that hook viewers in under 3 seconds.
Always structure scripts as: Hook → Problem → Solution → Proof → CTA
Keep total script under 60 seconds of spoken content.
Return ONLY clean JSON, no backticks, no explanation.
User message:
Write a YouTube Shorts script about: "{{ $json.Topic }}"

Return this exact JSON structure:

{
  "hook": "First spoken line — must create immediate curiosity or shock. Under 8 words.",
  "scenes": [
    {
      "spoken": "Spoken content for this scene (2-3 sentences max)",
      "image_prompt": "Visual scene description for AI image generation. Photorealistic, specific."
    }
  ],
  "cta": "Final call to action line. Under 10 words.",
  "title": "YouTube title optimised for search. Under 60 characters.",
  "hashtags": ["hashtag1", "hashtag2", "hashtag3"]
}

Create exactly 4 scenes plus the hook. Total spoken content must be under 60 seconds.
Model: openai/gpt-4o-mini via OpenRouter — approximately $0.001 per script.
Enable "Require specific output format" — this enforces the JSON schema and prevents GPT from returning narrative text.
Execute the node and verify: you should see a JSON object with a hook, scenes array of 4 objects, cta, title, and hashtags. If the schema breaks, add this to your prompt: "Double-check you have exactly 4 scene objects before returning."

Step 4 — JSON2Video API (render the Short)

Add an HTTP Request node.
Method: POST
URL: https://api.json2video.com/v2/movies
Headers:
x-api-key: [your JSON2Video API key]
Content-Type: application/json
Critical — use a vertical template. JSON2Video has both landscape and vertical templates. For Shorts you must use a 9:16 vertical template. Create or duplicate one in your JSON2Video dashboard before this step. Note the template ID.
Build your request body using expressions from the Script Agent output:

json{
  "template": "[your_vertical_template_id]",
  "variables": {
    "hook_text": "{{ $json.hook }}",
    "scene1_spoken": "{{ $json.scenes[0].spoken }}",
    "scene1_image": "{{ $json.scenes[0].image_prompt }}",
    "scene2_spoken": "{{ $json.scenes[1].spoken }}",
    "scene2_image": "{{ $json.scenes[1].image_prompt }}",
    "scene3_spoken": "{{ $json.scenes[2].spoken }}",
    "scene3_image": "{{ $json.scenes[2].image_prompt }}",
    "scene4_spoken": "{{ $json.scenes[3].spoken }}",
    "scene4_image": "{{ $json.scenes[3].image_prompt }}",
    "cta_text": "{{ $json.cta }}"
  }
}

The API returns a project_id immediately. Save this in a Set node for the polling loop.

Step 5 — Status polling loop

Shorts render faster than long-form videos — typically 2–5 minutes. The polling loop handles this.
Node sequence:
Wait node (90 seconds)
↓
HTTP Request GET → https://api.json2video.com/v2/movies?project={{ $json.project_id }}
↓
Switch node
status = "done" → output 1 → continue
status = "running" → output 2 → Wait 15s → loop back
status = "preparing" → output 2 → Wait 15s → loop back

anything else → output 3 → update Sheet "error" → stop
Use a 90-second initial wait (shorter than long-form because Shorts render faster) and a 15-second loop interval.

Step 6 — Download the MP4

Method: GET
URL: {{ $json.video_url }}
Response format: File ← CRITICAL — must be set to File, not Auto-detect
This is the same critical setting from the Instagram automation and the Top 10 Videos workflow. It is under Add Option → Response → Response Format. Without it you receive JSON metadata instead of binary video data. The YouTube upload will fail silently.

Step 7 — YouTube upload

Add a YouTube node.
Operation: Upload Video
Title: {{ $('Script Agent').first().json.title }}
Description: {{ $('Script Agent').first().json.hashtags.join(' ') }}
Category: Science & Technology (or your niche)
Privacy: unlisted
Binary data: toggle ON
YouTube Shorts detection: YouTube automatically identifies a video as a Short if it is vertical (9:16) and under 60 seconds. You do not need to add #Shorts manually — the format handles it. Adding #Shorts to the description is optional but can help discovery in the first 24 hours.
Auth setup: You will need the YouTube Data API v3 enabled in Google Cloud Console. In your OAuth app settings, add your n8n redirect URI to the list of authorised redirect URIs. Connect the credential in n8n and authorise it.

Step 8 — Update Google Sheet

Operation: Update Row
Match on: Topic = {{ $('Google Sheets').first().json.Topic }}
Update:
Script Status → "created"
Upload Status → "unlisted"
Video URL → https://youtube.com/watch?v={{ $json.id }}
On the next workflow run, this row is skipped. Add new topics with Script Status to-do whenever you want more content.

What breaks

JSON2Video template mismatch:

If your variable names in the POST body do not match the variable names in your JSON2Video template, the render succeeds but the output is empty scenes. Log your template variable names exactly and match them in the n8n expression.

YouTube Short not recognised as a Short: Your template is not 9:16, or the video is over 60 seconds of content. Check your JSON2Video template dimensions and total scene duration.
Script Agent returns wrong scene count: Add to prompt: "You MUST return exactly 4 scene objects in the scenes array. Count before returning." GPT-4 mini occasionally returns 3 or 5 without this constraint.
Google Sheets filter stops working: Trailing space in the to-do cell value. Check with =LEN(A2) — if it returns more than 5, there is a hidden character.

Scaling this up

Once the single-video flow runs cleanly:
Replace the Schedule Trigger with a daily trigger set to 9 AM. Your Sheet becomes a content queue — add topics whenever inspiration hits, the workflow empties the queue daily.
For batch processing multiple Shorts per day, change the Sheets Limit from 1 to 3. Run the workflow three times per day via a cron trigger. Watch your API costs — JSON2Video charges per render.

Full article and workflow diagram at elevoras.com.
Building a variation of this? Drop your topic niche and node count in the comments.