Blog

When I started my n8n journey, credentials weren’t an issue for me, it was all plug and play and everything seemed to work, then I stopped workflow for few weeks, and started the workflow again, then I got credential error. I was like! what! what just happened, then I had to re-authenticate to make it work.

But, what if this issue constantly happen for n8n workflow builder occasionally, that’s pure annoyance. so the builder needs to rinse and repeat. So OAuth2 clients needs to be refresh it’s tokens.

This ain’t a bug in your workflow. It’s how OAuth2 access tokens work by default. They expire after 7 days. Everytime they expire, you need to manually re-authenticate it (This method considered as a fix, but it’s not efficient). For automated workflows that should run without any interruptions.

I’ve seen lots of users had posted their frustration “credentials expiring” in reddit, and community forums.

Alright, let’s fix this credentials expiring issue right now.

Why Do We Need Access & Refresh Tokens?

The Refresh token in Google OAuth2 for n8n acts as a long-term key that allows n8n to generate a short-term access key (access token) without requiring you to log in manually every hour.

Two Types of Tokens

• Access token: This is the actual key n8n uses to read your sheets or add google calendar events. For security purposes this key will expire after 1 hour.
• Refresh token: This is a special key stored securely in your n8n database. It has only one job, ask Google to get a new token if current refresh token expired.

Next thing, we are gonna see how does this actually works.

When you setting up credentials, This is what will happen.

• Initial Auth Process: You click “Sign in with Google” in n8n.
• Exchange: n8n sends your consent code to Google and requests access_type=offline
• Storage: Google sends back an Access token and a Refresh token. n8n saves both.
• Auto Renewal
  • n8n attempts to run a node (e.g. Google sheet read)
  • if Google replies 401 unauthorized (Token expired), n8n automatically pauses
  • n8n sends a Refresh token to Google
  • Google validates it and return a new access token
  • n8n retries the request seamlessly.

How to Fix Credentials Expiry Error?

1. Go to Google Cloud Console > oAuth Consent screen
2. Navigate to Audience tab
3. Click the button to Publish App (push to production)

Note: You don’t need to submit your app for verification if you are only using it for yourself (using your own email address). However, you’ll see a warning screen says Google hasn’t verified this app, but you click advanced > Go to App(unsafe) to bypass it.

Configuration Checklist

To ensure the Refresh token mechanism work correctly, Your Google Cloud Console settings must match this criteria.

• Redirect URL: Must be exactly https://[YOUR-N8N-DOMAIN]/rest/oauth2-credential/callback or https://localhost:5678/rest/oauth2-credential/callback

• Scopes: if you add any new scopes (e.g., adding Gmail to an existing Drive credentials), the old Refresh token may become invalid. You must re-authenticate to generate a new one that covers all the updated scopes.

If you’re setting up n8n credentials for the first time or working with other services, Check our n8n credentials and service guide for step by step instructions across all the major platforms.

Your workflow should now run uninterrupted. No more weekly re-authenticate cycles.

Handling errors gracefully is one of the most important skills you need to master in n8n to keep your workflows running without interruption.

I built a workflow that scraped product data from a website, enriched it through an API, and added everything to Google Sheet. Tested it multiple times. Worked perfectly every time.

Set it to run every hour before going to bed. Felt pretty good about it though.

Next morning, I checked the sheet, same data from yesterday. Nothing new has been enriched, and saw my workflow stopped at 5:12 AM.

The website was down for maintenance. Just a 20-minute blip. But my workflow didn’t recover. Didn’t log error. Didn’t retry. Just stopped.

Lost 9 hours of data collection because I didn’t know handle a simple error at that time.

This is the reality of automation without error handling

APIs go down. Websites change their structure. Data comes in unexpected formats. Internet connection issues. Rate limits. Even the most carefully designed workflows WILL encounter problems.

The difference between fragile workflow and a production-ready automation isn’t avoiding errors (that’s impossible in my personal experience). It’s building workflows that can detect problems, recover gracefully, and keep running even when things go wrong.

In this guide, you’ll learn

• The most common errors you’ll face in n8n (and why they happen)
• How to build workflows that notify you when problems occur
• Practical strategies to validate data before it breaks your workflow
• Real working examples you can copy and test it immediately

The Most Common n8n Errors (and Why They Happen)?

When building a workflow in n8n, you’ll typically encounter these errors.

Error Type	What it looks like	Why it happens
HTTP failures	ETIMEDOUT, getaddrinfo ENOTFOUND	API is down, internet dropped, or wrong URL.
Auth errors	401 Unauthorized, 403 Forbidden	Expired API keys, missing headers, or stale OAuth tokens.
Rate limits	429 Too Many Requests	You hit your API quota or are requesting too frequently.
Missing data	Cannot read property ‘x’ of undefined	A field doesn’t exist, or previous nodes returned empty results.
Timeouts	Execution timed out, 10000ms exceeded	Processing too much data or the API is too slow.
JSON errors	Unexpected token < in JSON	The API returned HTML (an error page) instead of JSON.
Config errors	Column “Name” not found	Changed Google Sheet headers, deleted Slack channels, or typos.

The Pattern You’ll Notice

most errors fall into three categories

1. External failures (APIs down, network issues) – Need retry logic
2. Data problems (missing fields, wrong format) – Need validation
3. Configuration mistakes (wrong credentials, typos) – Need testing

The 3 Essential Error Handling Techniques

Now that you know what errors to expect, let’s talk about how to actually handle them. You don’t need complex setups or advanced knowledge. These three techniques will cover 90% of your error handling needs.

Technique 1: Error Trigger – Get Notified When Things Break

What it does: Catches any error in your workflow and lets you know immediately via slack, email, discord or wherever you want.

When to use it: Every production workflow. Period. If a workflow runes without you watching it, you need to know when it fails.

Before you setting up Error Trigger, make sure:

• Your main workflow uses an automated trigger (e.g, schedule, Webhook, etc)
• Your Error Workflow is published/active (not just saved)
• Critical nodes don’t have continue on fail enabled in their individual settings
• You have notification credentials setup. (Gmail, slack and etc)

Alright let’s get things step by step, then you would understand what it is.

Step 1: Create a workflow and add Error trigger, and also connect node of Gmail or slack to pass the appropriate information to the end-user

Step 2: Go to Your Main Workflow > Settings > Error Workflow > Select your Error Workflow

That’s it. so whenever you encountered any workflow errors, then Error Workflow will automatically triggers and notify you via an email. It totally depends on what kind of notification node you use, and yet you still can use slack, telegram or whatsapp to reach out with the exact error.

an example of email I received due to an error that I made purposely to show you all how it should work.

Step 3: Test it

Since Error trigger doesn’t work with manual executions, you need to test it with an automated trigger

1. Add a Schedule trigger to your main workflow (set to run every 1 minute)
2. Make sure workflow will fail (wrong API URL – In HTTP node, add GET , and change the URL to somewhat like googleyysadas.com
3. Wait for the scheduled execution
4. You should receive an error notification

After testing it, you can switch back to your preferred trigger type.

Technique 2: Validate Data Before Processing It (IF Nodes)

Check if data exists and is valid BEFORE you try to use it. Prevents crashes from missing or malformed data.

When to use this: Anytime you’re processing data from external sources (Google Sheets, APIs, webhooks, web scraping) where you can’t guarantee the format of completeness.

Example: Validating customer data

I have a customer database with 766 contacts in Google Sheets. Before sending them automated emails, I need to make sure each contact has a valid status field but not empty.

The Setup:

• Manual trigger: to start the workflow
• Google Sheets: Reads customer database (766 contacts)
• IF Node: Checks “Is status field is empty?”
  • True Path: 766 items with valid status (process manually)
  • False Path: contacts with missing status (log or skip)

The Result:

All 766 contacts had valid status fields, so they all went through TRUE path. If any contacts had missing status, they would have gone to false path where you could,

• Log them to an “Error Sheet”
• Skip processing them
• Send a notification about incomplete data.

Without this validation, the workflow would crash the moment it tried to use a missing status field. With validation, it gracefully handles the incomplete data.

Technique 3: Status Tracking With Continue on Fail

I’m going to show you production-ready pattern I use when processing large batches of data. Instead of just letting failures disappear into execution logs, I update my Google Sheets or database to track exactly which items succeeded and which failed.

Pattern: Instead of stopping on the first error, we let the node fail, catch it, and record the results in the database.

FYI: these Phone # are fake. generated with claude.

The Complete Setup

I have 766 customers contact in Google Sheet. I need to send them all welcome emails, but I know some emails address might be invalid or cause errors. Here’s how I handle it.

The Workflow breaks down like this

1. Read all 766 contacts from Google Sheet
2. Loop over items – Process them in batches (1 by 1 or you can add 50 too)
3. Gmail node with Continue on Fail enabled – This creates two outputs paths
   • Success path: Email that sent successfully
   • Error path: Emails that failed
4. Update success: If email sent successfully, update the sheet with status = SENT
5. Update failed: if it fails, update the sheet with the status = Failed
6. Wait 5 seconds: it’s better to give nodes a break.
7. Loop back: Process the next batch.

Why this works flawlessly?

When I ran with workflow with 766 contacts:

• 760 emails sent successfully (marked SENT and it was my end-goal for this automation)
• 6 emails failed (marked Failed)
• I got a complete audit trail
• So I create a new workflow, and add a schedule trigger to try out failed ones.

This pattern scales. I’ve used it with 50 contacts and with 5000 contacts. Same workflow, just adjust the batch size.

My Final Thoughts

Remember the workflow I told you about? the one that stopped at 5:12 AM and cost me 9 hours of data collection?

I rebuilt the full framework with these error handling I covered today. I saw lots of complex stuffs in the n8n community regards to error handling, but these 3 would be sufficient, perhaps totally depends on the use-cases and different situations.

so my full framework running for couple of months and processed around 50k data and hundreds of errors, yeah obviously that’s goes for all of us. But it never stops anymore. It logs the errors, update sheets (now data-table), notifies me if needed, and keep processing everything else.

That’s the difference.

In my previous post, I showed you how to handle rate limits when calling external APIs – It’s a defensive side of rate limiting.

Today we are going to learn a production-grade rate limiting with Redis.

Just assume that you’ve created a custom form in WordPress to obtain leads, and of course, you might encounter some unusual form submissions or spams like 10,000 submissions in a minute, but it’s all are worthless leads – To prevent this, we are going to add a guard, that’s going to strictly allow few people only for a certain time period. That’s what it is.

So we are going to build such a handy workflow to handle such attacks efficiently with Upstash + n8n.

Why Redis for Rate Limiting?

I added this sub-heading because one of a commenter in my reddit-post shared the same question? Why redis for rate limiting?

You might be thinking “Can’t I just use n8n’s built-in throttling?”

Aye, sure, for throttling your requests to external APIs, but for protecting such a case I have mentioned above, then you should need a custom solution. That’s where Upstash Redis comes in to the play.

• Persistent State: Data lives outside n8n’s memory. Workflow restarts don’t reset your counters. This is critical for production
• Speed: In-memory operations happens in microseconds. Your rate checks add virtually zero latency to each requests.
• Built-in TTL: Key automatically expires, No clean-up jobs, No database bloat, Set it to 60 seconds. Perfect for time-windowed rate limiting
• Per-use tracking: You can rate limit by email, IP, API Key, or any identifier. Each user get their own counter.
• Atomic Operations: the INCR command is thread-safe, Multiple simultaneous requests won’t break your counter – crucial when handling concurrent requests.

Why Upstash Specifically?

• Serverless (no Redis server to manage or maintain)
• Global edge network (low latency worldwide)
• Generous free tier. (500k commands per month / 50GB Bandwidth)
• Pay as you go – $0.2 / 100k commands

Alright, for our workflow we don’t need the pay as you go, so you can stay for free tier, until you hit the maximum requests. Literally, small to medium sites you’ll stay on the free tier forever.

Understanding Rate Limiting Pattern

Before we dive into the workflow, let’s understand how counter-based rate limiting works, It’s beautifully simple.

1. Requests comes in > Extract an identifier (email, IP or API Key)
2. Increment counter in Redis > Add 1 to counter, set TTL if it’s a fresh request
3. Check the counter > if it’s above your threshold, deny the request
4. Allow or deny > Either process the requests or return 429 (Too many requests)

The magic is in the TTL (time to live). When you set 60-seconds TTL, redis automatically deletes the key after 60 seconds. No cleanup needed. The counter resets automatically.

so if someone submits your form at 10:00:00, they can’t submit until 10:01:00. Simple, effective and spam-proof.

Real World Example Workflow

To show you how this works in practice, let’s implement rate limiting for a WordPress website contact form that saves to Google sheet.

This exact pattern works for any API endpoint you need to protect.

• Custom API endpoints
• Webhook receives from external services
• Form submissions (any platform, not just WordPress)
• User action endpoints (voting, commenting, or ordering)
• Data collection endpoints

Our demo scenario

• WordPress contact form submission via Webhook.
• Data should go to Google Sheet
• Limit: 1 submission per email for 60 seconds
• This protects our Google Sheets API quota and prevent spam

The Workflow

Let’s break down each node and understand the pattern

Node 1: Webhook Trigger

This is your entry point, The WordPress form submits data here via a webhook. Could be Contact Form 7, WPForms, Gravity Forms or any form plugin that supports webhook.

Read Here: Webhooks in n8n for Beginners

The incoming payload looks something like this

{
  "body": {
    "your-name": "Shajid Shafee",
    "your-email": "Test@ShajidShafee.com",
    "your-message": "Hey! This is my first feedback".
}

Different form plugins structure their data differently, Some use body.your-email other just use your-email. That’s why we need smart fallback handling in the next step.

Node 2: Redis Increment

Here’s the steps you need to take to configure Redis Node.

• Step 1: Go to Upstash.com and create a FREE account
• Step 2: Go to your workflow and add a Redis Node

• Step 3: In Upstash, Create database. Give a name, and Select US-East-1 AWS for the server location, and use everything for free.

• Step 4: Go to Workflow, Configure the Redis node,
  • Host: Paste the endpoint
  • Port: 6379
  • Password: Paste the Upstash database token
  • Database Number: 0
  • By adding this save the credentials, you’re good to go

This is where the magic happens. We’re using Redis’s INCR command to atomically increment a counter

Key structure

rate_limit:{{$json.body["your-email] || $json["your-email" || $json.email || "unknown"]}}

paste the above code block directly on the redis node.

Let’s break down the expression

• {$json.body["your-email] – Checks Contact Form 7 format, because I’m using contact form 7
• || $json["your-email"] – Fall back for WP Forms
• || $json.email – Fall back for other plugins
• || "Unknown" – Last resort if no email found

so if the email is john@example.com, your redis key becomes

rate_limit:john@example.com

TTL: 60 seconds

This means the key (and its counter) will automatically disappear after 60 seconds. The user can submit again after TTL expire.

What happens in Redis?

• First submission: Key doesn’t exist > Create it, set it to 1, add 60s TTL > Returns 1
• Second submission (within 60 seconds): Key exists > Increment to 2 > Returns 2
• After 60s TTL: Key auto deleted > Next submission for the identifier start fresh at 1

Node 3: Conditional Check (IF)

Now we check the Redis response to decide, allow or deny (rate limit)

Expression

{{ Number($json.data ? $json.data : Object.values($json)[0]) }} > 1

This parses the redis response and converts into a Number. then checks if it’s greater than 1

Why > 1 instead of >=2?

Same logic, cleaner to read. If the counter is greater than 1, it means they’ve already submitted once in the last 60 seconds.

• Counter = 1: First submission > False > Allow it
• Counter = 2+: Already submitted > True > Rate Limit

The IF Node has two outputs

• True output (rate limit): Goes to 429 response
• False output (allowed): Goes to Google Sheet

Node 4(a): Rate Limited Path (Responded to Webhook)

When someone hits a rate limit, we return a clear response

{
  "error": "Too many requests",
  "message": "Rate limit exceeded. try again soon",
}

This stops the request. No data reaches your Google Sheet. No email notification sent. Just clean block.

Node 4(b): Success Path

When the request passes the rate limit, we process it normally.

• Google Sheet Node: Append or update the row
• Respond to Webhook: Return success message

Success Response

{ "ok": true, "message": "Form submitted" }

The form displays the message to the user, clean, professional. DONE.

Quick Start Checklist

Ready to implement this or to check whether this pattern is actually working.

Setup

• Create upstash account and database
• Copy the endpoint and Token
• Add redis credential in n8n

Build Workflow

• Add Webhook trigger (or any other data source that is sending)
• Add Redis increment node with your key structure
• Add IF condition to check counter
• Add two response nodes 429, and success
• Connect your actual processing (Google sheet, Airtable, or database)

Test

• Send first request > Should Succeed
• Send second request immediately > Should get 429 error
• Wait 60 seconds > Should succeed again

That’s it. Production grade rate limiting is ready to serve.

Conclusion

Rate limiting isn’t just for big tech companies or SaaS platforms. With Upstash Redis and n8n, you can implement production grade rate limiting without writing code.

• Protect any endpoint from abuse (forms, APIs, webhooks, actions)
• Stay within the downstream service quotas (Google Sheet, Airtable, database)
• Prevent spam and bot attacks automatically
• All for $0.00/month on Upstash free tier
• Deploy this workflow in just 15-20 minutes with no infrastructure management

The pattern is dead simple. Increment counter, check threshold, allow or deny. But the application are endless.

Whether you’re protecting a WordPress form, a custom API, a webhook receiver, or user actions – the Redis rate limiting pattern works the same way every time.

Start with the example I showed you, then adapt it to your specific needs and use case. You just connect the dots in n8n.

You’ve built a slick n8n workflow to update 500 customers records in your google sheet, you hit execute, watch the first rows update perfectly, and then BAMM! everything stops.

Error: Rate limit exceeded.

Half your data is updated, and another half isn’t. Literally, your workflow is broken. Sounds familiar? ahem. You just hit an API rate limit.

Maybe you’re a beginner to this space, well, no worries. I’ve got you covered. If you’re just getting started, my complete n8n beginner guide is the best place to build your foundation first

What Are API Rate Limits? ( And Why do they exist)

Think of an API Rate limit like a speed limit on highway. It’s not there to annoy you or make miserable – It’s there to keep you safe and everyone safe.

APIs limit how many request you can make in a specific time period. This prevents server overload, protect against abuse, and yes, sometimes encourages you to upgrade to a paid plan.

Read Here (Advanced-method): How to use Redis to Rate Limit Your Form Submissions

For Google Sheets specifically,

• 100 requests per 100 seconds per user
• That’s roughly 1 request per second
• Exceeding this triggers the dreaded 429 status code error

How You Know You’ve Hit a Rate Limit?

The signs are pretty obvious,

Error messages like

• “Rate limit exceeded”
• “429 Too many requests”
• “Quota exceeded”

Your workflow

• Stops mid-execution
• Processes the first chunk of data, then fails
• Shows partial results (100 items worked, 400 didn’t)

To fix this, you need a solution and strategy. Let’s get started

Level 1: Throttling (Split in Batches)

When an API or Google Sheets limits on how many requests you can send per second, you don’t want to flood it – you slow down and batch it.

In this example, we have 500 customers that needs to be written into a Google Sheet. If we send all 500 requests at once, we will hit Google’s rate limit.

So instead, we:

In Loop over items node, you can add batch size to 5 to create a chunks in data.

• Batch 5 customers at a time
• Write them to the sheet
• Wait 10 seconds
• Repeat until all 500 are done

Workflow Breakdown

For this workflow, I created a 500 customer sample data in JSON.

Node	Purpose
Manual Trigger	Starts the workflow manually
500 customers in JSON	Stores your dataset (simulated API for tutorial purposes, and for your case, maybe you might have in database or CRM)
Enriching data	Optional: Filters only the fields you care about (name, email and etc)
Batching Items (Split in Batches)	Groups the customers in batches of 5
Customer DB (Google Sheet)	Appends or update each batch
Processed data (function)	Optional: Logs the batch count
Wait 10 Seconds	Prevents rate limiting (Throttle delay)
Loop back	Returns to batching items until all 500 are processed

I hope this example might give you some glimpse of how to rate limit properly using Loop over items (Split in batches) node and Wait node.

Level 2: Retry Logic

In Level 1 throttling, where you slow down requests using delays and batching, then level 2 = Retry handling (Graceful recovery) – where you respond intelligently when rate limits or temporary failures actually happens.

In our previous workflow example, we created our retry handling if Google sheets throws any limit error.

• In our Google Sheet Node, go to settings, and toggle Retry On Fail
• Keep the Max. tries as 3 and Wait between tries as 5000ms which is 5 seconds.
• On Error, select Continue (using error output)

• On Error, create a Wait Node and assign 10 seconds.
• Plug back the Wait Node to Customer DB (Google Sheet)

By this way, we gracefully handling the errors, in case if we get any rate limit error. perhaps we need to assign 60 seconds for the Wait Node to prevent the rate limit. It totally depends on the API’s rate limit.

As we can see here, green highlighted areas on Error output resolved the rate limiter, and passed on to success route efficiently.

My Personal Tips

• Do the Math first
  • 500 customers / 5 per batch x 10 seconds wait = ~16 minutes total. Know your execution time upfront so you’re not surprised.
• Check the API Docs
  • Google Sheets – 100 req / 100 sec
  • Airtable – 5 req / sec
  • Notion – 3 req / sec
  • Each API is different – always check their limits first
• Test with Small Batches
  • Before running 500 records, test with 20.
  • Catch issues early, iterate faster
• Monitor Your Executions
  • Check n8n’s execution logs regularly
  • If you see multiple retries, your wait time is too short

Rate limits don’t have to break your workflows. With throttling and retry logic, you can handle them gracefully:

Throttling prevents you from hitting limits in the first place

Retry logic handles the occasional hiccup when limits do hit

Start with these two techniques, and you’ll be handling 99% of rate limit scenarios like a pro.

Think of a webhook as a doorbell for your workflow.

When something happens in one app (like a customer filling out a form, or someone making a payment), that app rings the doorbell, the webhook – which then starts your n8n workflow. No manual clicking. No constant checking. Just instant action.

The old way would be like repeatedly asking, “Did anything happen yet? How about now? Now?” That’s called polling, and it’s slow and annoying.

Webhooks flip the script. Instead of you asking, the app tells you immediately when something happens.

Setting Up Your First Webhook in n8n

Here’s how simple it is,

Step 1: Open n8n and create a new workflow.

Step 2: Click “Add first step” and search for “webhook” node. Add it to your workflow canvas.

Step 3: You’ll see two important things

• HTTP Method: Choose POST if you’re receiving data (most common), or GET if you’re just triggering an action.
• Path: This creates your unique URL – n8n generates one automatically, but you can customize it.

Step 4: Click “Listen for Test Event” at the top of the webhook node. n8n will now wait for incoming data.

Step 5: Copy the test URL that appears. This is your webhook address where other apps will send data.

That’s it. Your webhook is ready to receive data.

Understanding Test URL vs Production URL

Before we dive into real use cases, you need to understand these two critical URL pattern in n8n.

Test URL (Contains /webhook-test/)

• Only for testing inside in n8n
• Works when you click “Listen for test event”
• Stops after one request
• Perfect for quick debugging purpose

Production URL (Contains /webhook/)

• For real integrations with external services
• Only works if the Workflow is ACTIVE
• Always listening 24/7

When Should You Use Webhook in n8n?

Use webhooks when,

• You need instant notifications (new orders, form submissions, payment alerts)
• You’re connecting apps that don’t have direct integrations.
• You want to build custom APIs without coding
• You’re tired of manually checking multiple platforms

Skip webhooks when,

• You need to pull data on your own schedule (use scheduled trigger instead)
• The app you’re connecting doesn’t support webhooks (use polling nodes)

Alright, let’s create a workflow how to use webhook properly.

How to Send WordPress Form Submissions to Google Sheets

Well, this is going to be a good workflow to test it out how webhook actually works. Not only that – I’ll also show you how to make your local n8n setup accessible to the public internet temporarily using ngrok.

Step 1: Set Up the Webhook in n8n

• Create a new workflow in n8n
• Add a Webhook node as the first step
• set the HTTP method to POST (because the form will send data)
• Customize the path to something memorable like /grab-contacts
• Note down this path – you’ll need it in the step 3

Step 2: Making Webhook URL Publicly Accessible

Explanation: When you run n8n locally (e.g http://localhost:5678), your webhook URL might look like this “http://localhost:5678/webhook-test/abcd123” but this only works on your computer – It’s not reachable from the internet. So if a service like WordPress tries to send data to it, it will fail because WordPress can’t reach your localhost.

So we are going to use a tool called “ngrok” that acts as a secure tunnel between the public internet and your local computer.

• Create an account in ngrok – It’s totally free.

• Install ngrok on your windows / mac or linux.

• Setup your ngrok: make sure once installed, open up the terminal, and ngrok config add-authtoken <your auth token>
• Now go to your terminal and type this code ngrok http 5678

• Now it created a tunnel you’ll get a forwarding address look like in the above image, https://address.ngrok.free.dev

Step 3: Connect Your WordPress Form

For this tutorial, I made a separate page in WordPress, created a simple form with contact form 7 plugin, and added the shortcode on that page.

• Install the plugin called “Contact Form 7” (most popular WordPress Plugin)
• Install another plugin called “CF7 to Webhook” – so this plugin is an add-on for Contact Form 7 which enables the Webhook integration.

• Go to Your Contact Form 7 settings and find the webhook integration section
• Paste your complete production webhook URL in this format
  https://your-ngrok-url.ngrok-free.dev/webhook/grab-contacts

Optional: Understanding Webhook URL Structure

Your complete webhook URL has three parts

• URL: https://your-ngrok-url.ngrok-free.dev (ngrok url) or your localhost. For this tutorial, we go with the ngrok url.
• Webhook prefix: /webhook/
• Your custom path: grab-contacts

Common mistake: Don’t use /webhook-test – that’s only for testing inside n8n. Always use /webhook/ for external integration.

Step 4: Connecting Google Sheet Node

• Insert the next node after the webook as Google Sheet.

• Make sure to add the correct credentials
• Operations: Append (this adds a new row each time when the new data comes)
  • Or, If you want to avoid duplicates use Append or Update.
• Select your Document and Sheet
• Map each column manually.
• Column to match on as name because names are going to be unique. (However, email is the correct column to match on to avoid duplicate emails) It’s totally up to you.

• Values to send
  • `{{ $json.body[“your-name”]}}`
  • `{{ $json.body[“your-email”]}}`
  • `{{ $json.body[“your-message”]}}`

Step 5: Testing the Workflow

Before testing with WordPress, you MUST activate your workflow.

• Click the toggle switch in the top-right corner to turn it “Active“
• Once activated, you’ll see the production URL

• Go to your form, and submit with the information

• In n8n, click the Executions tab at the top
• Click on the most recent execution (should be at top of the list)
• You’ll see your workflow with green checkmarks if successful
• Check your Google sheet – you should see a new row with the form data

Common Troubleshooting Tips

• There was an error trying to send your message
  • Tip: Make sure to activate your workflow, not just listening for test events

• ngrok shows the data but n8n doesn’t
  • Tip: Check the ngrok visual inspector by going to http://localhost:4040 in your browser. If you see the POST request there with 200 OK status, ngrok is working fine. The issue is likely that your n8n workflow is not activated. Always check your executions tab in n8n – If executions are appearing but failing. Click on them to see which node has the error

• Data appears in n8n but not in Google Sheets
  • Tip: Verify whether your Google sheet is connected properly, and you’ve selected the right spreadsheet.

What You Just Accomplished

Congratulations! You’ve just built a production-ready automation that,

• Captures form submission in real-time (no-delays)
• Automatically saves data to Google sheets
• Works 24/7 without any manual interventions
• Can be extended with additional nodes (slack notifications, passing the data to CRM and much more)

Start with something simple – maybe auto-saving form submissions or getting Slack alerts. Once you see it working, you’ll find dozens of places where webhooks can save you hours every week.

Well, the best part is? No coding required. Just drag, drop, connect, and let your workflows do the heavy lifting.

Now go build something awesome! 🚀

I hope you had a great experience creating your first hello world workflow. This post is part of my complete n8n beginner guide — covering everything from install to AI agents

In n8n, you need to understand how to plug appropriate nodes, and how to pass the data. This guide is going to explain and simplify the core mechanisms.

What is a Workflow?

Think of Workflow as a chain of dominoes. The first one falls (the trigger), and it sets off a chain reaction where the each domino (node) knock down the next, creating an automated sequence of events.

In a n8n, a workflow is your canvas where you visually design the automation by connecting different nodes together. Each workflow has,

• A trigger – What starts the workflow whether manual trigger, on a scheduled call or On webhook call.
• Actions – What happens when triggered (sending emails, updating database, calling APIs)
• Logic – How data flows and decision are made out along the way.

Understanding Nodes: The Building Blocks

Nodes are the individual building blocks of your workflow. Each node performs a specific function, like connecting to service, transforming the data, or making a decision.

What makes nodes powerful is their simplicity. Each one does ONE thing really well. One node might fetch data from an API, another might filter that fetched data, and third might send it somewhere. By connecting those focused nodes together, you can build complex automations.

Every node has 3 distinguish parts,

• Inputs – what data it receives from the previous nodes.
• Configuration – Settings that control how it behaves.
• Outputs – The results passes to the next node.

You can click on any node to configure it, test it independently, and see exactly what data it’s working with. And you can reuse the same type of node multiple times in a workflow – Need to call three different APIs? Just add three HTTP request nodes just simple as that.

Types of Nodes

In n8n, nodes fall into 3 main categories, and understanding these categories is crucial to building workflows that work. Each type plays different role in your automation.

Trigger nodes start your workflow – Every workflow needs exactly one trigger to tell it when to begin execution.

Action nodes that do the actual work – They’re like “Do that” part. These nodes interact with external services, manipulate data, and perform the operations you want to automate. You’ll typically use multiple action nodes in a single workflow.

Logic nodes control your workflow – They’re the decision makers and traffic controllers for your workflow. They determine which path your data takes, whether certain steps should run, and how data from different sources combines.

Below table would gives a comprehend list of nodes that you can start off right away.

Node Category	Node Name	What it Does	When to Use it
Trigger	Manual Trigger	Starts workflow with a button click	Testing workflows or on-demand automation
Trigger	Webhook	Starts when receiving HTTP request	Integrating with external services, form submissions
Trigger	Schedule Trigger	Starts at specific times/intervals	Daily reports, regular data syncing, scheduled tasks
Trigger	Gmail Trigger	Starts when new email arrives	Email automation, inbox monitoring
Trigger	Google Sheets Trigger	Starts when row is added/updated	Form responses, spreadsheet-based workflows
Action	HTTP Request	Calls any REST API	Connecting to services without native nodes
Action	Gmail	Sends emails	Email notifications, confirmations
Action	Slack	Posts messages to channels	Team notifications, alerts
Action	Google Sheets	Reads/writes spreadsheet data	Data storage, reporting, logging
Action	Postgres/MySQL	Database operations	Storing structured data, querying records
Action	Set	Creates or modifies data fields	Cleaning data, preparing for next node
Action	Code	Runs custom JavaScript/Python	Complex transformations, custom logic
Logic	IF	Routes data based on conditions	Different actions for different scenarios
Logic	Switch	Routes to multiple paths	Categorizing data, complex routing
Logic	Merge	Combines data from multiple nodes	Bringing together different data sources
Logic	Split in Batches	Processes items in groups	Handling large datasets, API rate limits
Logic	Wait	Pauses workflow execution	Delays between actions, waiting for events
Logic	Filter	Keeps only items matching criteria	Removing unwanted data before processing

Alright, that’s so far great, and let’s learn these nodes individually with practical examples to create your next workflow right away.

Trigger Nodes

This specific node is the starting point, whether you can manually click on it to start the workflow, or maybe by triggering an external event that would start the workflow. I have listed below the main important trigger nodes that can be start a workflow in various ways.

Trigger Manually

• Simplest trigger in the n8n, It just waits for you to click the “Execute workflow” button. that’s it then workflow will start to run.
• Testing and Development: Build your workflow step by step without waiting for real triggers.
• On-demand Automations: Tasks you want to run manually when needed.
• Learning: Understanding how nodes work without any external dependencies.

On App Event

Triggers when something happens in external application like Gmail, Google Sheets, Slack, or any integrated service.

How it Works: n8n connects to the app and listen for specific events. When that event occurs (like a new email, a row added to a sheet, or a file uploaded), your workflow starts automatically.

Common App Event Triggers

• Gmail Trigger – New email arrives in your inbox.
• Google Sheets Trigger – Row is added or updated
• Google Drive Trigger – File is created or modified
• Slack Trigger – Message posted in a channel
• Airtable Trigger – Record is created or updated

A simple real world example, “When a new row is added to my ‘Leads” google sheet, send the details to our CRM and notify the sales team in slack”

On a Schedule

Triggers your workflow at specific time or intervals – like a cron job or alarm clock for your automation.

How it Works: You define when the workflow should run, Every hour, daily at 9:00 AM, every Monday, or custom intervals. n8n’s scheduler handles the rest.

A simple real world example, Daily report generation at 8 AM on Weekdays.

On Webhook Call

Triggers when n8n receives an HTTP request to a unique URL – perfect for integrating with external services or building APIs.

How it works: n8n gives you a unique webhook URL. When any service sends and HTTP request (GET, POST, PUT, etc.) to that URL, your workflow starts, and the request data becomes available.

This is one of a powerful node, you know why?

• Instant – No polling delay, executes immediately.
• Universal – Any service that can make HTTP requests can trigger your workflow
• Flexible – Receive data in JSON, form data, or query parameters.

Real world example, When you receive a payment from Stripe, and then webhook listens to it, and update it database and as final outcome, sends receipt to the user which means you don’t need to send receipts manually. That’s great isn’t it.

On Form Submission

A specialized trigger for handling form submissions – essentially a webhook configured specifically for forms with a built-in form page.

How it works: n8n generates both a webhook URL and a hosted form page. Users fill out your form, submit it, and the data triggers your workflow.

When Executed By Other Workflow

Allows one workflow to trigger another – essentially building modular, reusable automation components.

How it works: Workflow “A” includes an Execute Workflow node that calls Workflow B. Workflow B starts with “When Executed by Another Workflow” trigger and receives data from Workflow A.

On Chat Message

Triggers when a message is received in the chat platforms – build chatbots and conversational automations.

How it works: n8n connects to chat platform (Telegram, Discord, Slack, WhatsApp, etc.) and listens for messages. When a message arrives, your workflow processes it and can respond.

When Running Evaluation

A specialized trigger for testing and quality assurance workflows, particularly for AI and LLM applications.

How it works: Used in conjunction with n8n’s evaluation and testing features to run workflows against test datasets and validate outputs.

Note for beginners: This is an advanced trigger. Unless you’re specifically building testing or AI evaluation workflows, you likely won’t need this one when starting out.

There are multiple use cases for this specialized trigger.

• Testing LLM prompt outputs.
• Validating data transformation
• A/B testing different workflow paths
• Quality assurance for automated process

Other Ways

n8n is flexible and support additional trigger methods

Workflow trigger node: similar to “When Executed By Another Workflow” but with more control and error handling options

Error Trigger: starts workflow when another workflow encounters an error – perfect for error handling and alerting.

Custom Triggers: Using Code node with HTTP request nodes, you can build custom trigger logic for specialized use cases.

Action Nodes

Action nodes are where the magic happens, while trigger nodes start your workflow, action nodes perform the actual tasks, calling APIs, sending emails, updating databases, transforming data, and connecting to services.

Here we are going to show you the most essential action nodes to kick start your automation like a pro.

HTTP Request Node

I personally call this node as “The Swiss Army Knife for n8n” that connects to virtually any API or web service that speaks HTTP.

Should You Use This As A Beginner? Honestly? Maybe not yet. This node is incredibly powerful, but it requires understanding APIs and web requests. If you’re just starting with n8n, focus on nodes like Gmail, Slack, and Google Sheets first – they’re designed to be beginner-friendly. Come back to HTTP Request when you’re comfortable with n8n basics.

But if you’re ready to learn…

Just imagine that you want piece of information from a website, but you thinking without opening them in your browser, you want your workflow to fetch it automatically. The HTTP request node is like sending a messenger to a website to either,

• Ask for information (like checking the weather)
• Deliver information (like submitting a form)
• Update information (like changing your profile)

What It Does: Makes HTTP request (GET, POST, PUT, DELETE, etc.) to any URL. If a service has an API, this node can talk to it.

Gmail Node

Send, read, and manage emails directly from your workflows.

What It Does: Full Gmail integration – send emails, read messages, add labels, search inbox, and more.

Slack Node

Post messages, create channels, and interact with Slack workspaces

What It Does: Send messages to Slack channels or users, perfect for team notifications and alerts.

Google Sheets Node

Read from and write to Google Sheets – your cloud-based database for simple workflows.

What It Does: Full Google Sheets integration – add rows, update cells, read data, create sheets.

Common Operations

• Append Row: Add new data to bottom of sheet
• Update Row: Modify existing rows
• Lookup: find rows matching criteria
• Read: Get all data from sheet

Google Drive Node

Stores and manages files in Google Drive automatically. Upload files, create folders, download documents – all from your workflow

Example: you receive form submission with attachments > Save each attachment to a Google Drive folder named by date.

Beginner tips: Create a dedicated “n8n uploads” folder in Drive first. Then always upload to that folder – Keep things organized.

Airtable Node

Airtable is like Google sheets but more powerful – It’s a database that looks like a spreadsheet. This node lets you create, read, update, and delete records.

Example: customer fills out contact form > Create new record in Airtable “Leads” table > Team sees it instantly in their Airtable base.

Postgres Node (Database)

Connects to a PostgreSQL database to store, retrieve, and manage data using SQL queries.

Should Beginner Use This? Probably not at first. Postgres is powerful but requires,

• Understanding database architecture.
• Writing SQL queries
• Setting up a database server

If you’re beginner then start with Google Sheets, Airtable for now, once you had the enough knowledge about the database, then you can easily migrate to PostgreSQL.

Logic Nodes

Logic nodes don’t fetch data or send emails – they control HOW your workflow runs. They make decisions, combine data, filter items, and direct traffic.

IF Node

Makes a simple yes/no decision. If the condition is true, data goes one way. If false, it goes another way.

Example: Check if the order amount is over $100

• True path > Send to priority fulfillment + VIP Email
• False path > Send to standard fulfillment + regular email

Beginner tips: Start with simple conditions. Don’t try to check multiple things at once – use multiple IF nodes instead.

Switch Node

Routes data to different paths based on multiple conditions. Like IF node, but with more than two options.

Beginner tip: Always include a fallback route (Output 3) for data that doesn’t match any condition.

Filter Node

Removes items that don’t match your criteria. Only items passing the filter continue to the next node.

Beginner Tip: Use Filter early in your workflow to reduce items. Processing fewer items = faster workflow based on my personal experience.

Merge Node

Anytime your workflow splits into multiple branches and you need to bring them back together. That’s what happening in the merge node.

Split In Batches Node

Breaks large lists into smaller groups and processes them one group at a time. For an example, Instead of processing 1000 items at once, process 10 groups of 100 items.

Why Use It?

• API Rate Limits – Many APIs only allow X requests per minute
• Performance – Processing 1000 items at once can crash workflows
• Control – Add delays between batches

Example: Send 500 emails, but Gmail limits to 100/minute

Beginner warning: This node creates a loop. Make sure you understand loops before using it, or your workflow might run forever.

Wait Node

Pauses your workflow for a specific amount of time before continuing. It is like a hitting the pause button. The Workflow sleeps, then wakes up and continue.

Example: Send a welcome email immediately, wait 3 days, send follow-up email.

Data Flow

Every nodes receives data from the previous node and passes it’s output to the next node. it’s really like running a relay where each runner (node) passes the baton (data) to the next runner.

What you need to understand

• Each node outputs JSON data.
• The next node receives the data as input
• You can reference data from previous nodes using expressions.

Debugging Data Flow

When things go wrong in your workflow (and, they will)

Check it out here: How to handle errors in n8n

1. “No Data” error > Previous node returned empty results
   • Solution: Check that node’s output tab
2. “Field undefined” error > You’re referencing a field that doesn’t exist
   • Solution: Inspect the data, check exact field names (case-sensitive!)
3. “Node not found” error > You renamed a node but expression still use old name
   • Solution: Update all expressions to use new node name
4. “Too many items” error > Workflow is slow or timing out
   • Solution: Add Filter node early, use Split in Batches for large datasets

Your First Data Flow Exercise

Try building this simple workflow to practice

1. Manual Trigger > Click to Start
2. Set Node > Create fake data

{
    "name": "your name",
    "task": "learn n8n"
}

3. Code Node > Add

return [{json: {...item.jsonm message: Hello ${item.json.name}!}}]

4. Execute > See how data transforms yourself.

Remember: Understanding the data flow is what separates beginners from builders. Take time to inspect, experiment, and see how data transforms. It’ll definitely click, I promise.

Final Thoughts

I’m still learning n8n myself. I still google “how to do X in n8n” more than I’d like to admit. I still build workflows that completely fail the first time I run them or goes out of the context in terms of logical.

But you know what changed? I went from “This is overwhelming” to “Oh! I know which node to use for this”. That shift happens faster than you think, usually around your 3rd or 4th workflow.

The community is super helpful. The documentation is solid. And most importantly, every problem you run into, someone else has already solved and posted about.

So if you take nothing else from this guide, remember start small, test often, and don’t be afraid to peek at other people’s workflow for inspiration.

Your automation journey starts with a single manual Trigger node. Everything else builds from there.

This workflow demonstrates the two core concepts of n8n: Triggers (what’s start the process also known as “Entry point”) and Data Flow (how information moves between nodes).

What you’ll get?

This workflow will teach you on surface level of how we pass the data from A to B. later on, we create more workflows like a real pro. Trust me. Once you complete this workflow, you will get to know many things.

Static Hello World Workflow

This is the easiest workflow in this post, and follow the instructions properly to evade unusual errors.

Step 1: New Workflow

Open your n8n instance whether it is self-hosted or cloud, click New in the top navigations or on your dashboard to start a blank canvas.

Step 2: Setup the Trigger Node

When you click on the “+” icon then sidebar will open up and asks what triggers this workflow? We’ve already talked a lot about triggers, you can check the reference links below once you complete this workflow.

Check it out here: Guide to Workflows, Nodes, and Data Flow

• Select the Trigger Manually

• Once you select the manual trigger, it will appear on the visual editor.

• Do nothing else on this node. It’s configured by default to run when you manually click on the execute workflow.

Step 3: Setup Action Node (The “Set” Node)

The Set node is one of the most important nodes, it allows you to create, modify, or remove data fields. This is just perfect node for “Hello World”

• Click the + button next to the Manual trigger node.
• Search for Set and select the node.
• In the Set Node configuration panel
  • Click Add field
  • In the new row, for the Value Name (Key), type message
  • For the value (Value), type Hello, World!
  • Click on the Back to Canvas or press esc

Now your entire canvas shows with two nodes such as manual trigger, and set node. Now hit on Execute Workflow.

However, you can double click on Set node to see the output. Which message says Hello, World! that’s great isn’t it?

Now let’s dynamically pass down the data

Passing Dynamic Data (Mapping) to Your Workflow

What we are going to do here is we are going to map data directly to Set node.

Step 1 : Configure Manual Trigger Node’s Output

• Double click on the Manual trigger node, then go to click on the pencil icon.
• You’ll see a code block space.

{
  "name": "Add Your Name Here",
  "status": "Ready"
}

Understanding the JSON structure (Optional)

The above JSON (JavaScript Object Notation) is the language of data in n8n. Every piece of data flowing through your workflow will look like this. The manual trigger node here is simulating the data you would receive from a real source. such as contact form submission or a database query.

Step 2: Code Block and Set Node

Each key (name and status) acts as a variable that we can access later using the dollar-sign expression ($).

• Copy the above code block and paste it on the Manual trigger node’s output.
• Save the code block.

• Go back to your canvas > Go to Set Node.
• On the left hand-side, You will see the name, and status value pairs.

• Now it’s time to map the values that are in the manual trigger.
• Go to your message field, Remove the previous text which Hello, World!
• Replace with Hello, {{ $json.name }}! Are You {{ $json.status }} to learn n8n?
• once you execute the workflow or that specific step, then you can see the output on right hand side.
• Now message contains, Hello, Shajid! Are You Ready to learn n8n?

Congratulations 🫸🏻, You have created your first n8n workflow successfully. Please share your workflow with us in our reddit community.

Once you’re comfortable with this workflow, head back to the complete n8n beginner guide to tackle the next step

If you’d any issue with the content, let me know directly via an email, hello@theowllogic.com

Installing n8n locally is one of the best decisions you can make for workflow automation.

Why? Because unlike cloud platforms that charge $20-50/month and limit your workflows, running n8n on your computer is completely free.

No restrictions on workflows, no execution limits, and your data never leaves your machine.

But here’s what nobody tells you: the installation process can be confusing.

Should you use npm, or docker? What happens when you close the terminal? Where are your workflows even saved?

I hope this helps you out.

NPM

• Quickest setup, users already familiar with Node.js.
• Prerequisites – Node.js and npm installed.
• Data persistence – Easy, data is saved locally by default.
• Recommended Ram – Minimum 4GB+

Docker

• More robust, production-like setup, better isolation.
• Docker Desktop installed.
• Requires setting up a persistent volume (covered below).
• 8GB+ (Docker takes resources)

I’ve been there. I spent hours figuring this out so you don’t have to.

This guide covers everything you need to install n8n locally – whether you’re on Windows, Mac, or Linux.

I’ve included screenshots for every step, troubleshooting for common errors, and honest advice about which installation method actually makes sense for you.

What you’ll get:

• Two installation methods explained (npm, Docker)
• Complete step-by-step instructions with screenshots
• Troubleshooting for the errors you’ll actually encounter
• Tips for keeping your installation secure and backed up

No technical jargon. No skipped steps. Just a straightforward guide to getting n8n running on your computer. Thank me later.

Ready? Let’s install n8n.

This is part of my complete n8n beginner guide — where I cover everything from install to AI agents.

Installing n8n locally with NPM

For those who know what NPM is? that’s great. but for those who don’t know? NPM stands for Node Package Manager which is opensource package manager for Node.js

Step 0: Installing Warp Terminal (Optional)

This is an optional method, and this is how I actually work though, Install warp (It’s free), and use warp as your terminal.

The reason I say install warp is perhaps windows users would have hard time terminal issues, sometimes leading PowerShell security issues. The above step is totally optional though.

Step 1: Verify Node Installation

Open up your terminal or use warp, and type node -v and npm -v you can check it out the below gif.

Most probably you won’t have installed the node.js. Let’s go with the step 2

Step 2: Install Node.js

• Go to Node JS official site, and click on download LTS version
• Based on the Operating system preference download the installer whether you got Linux or MacOS.
• Install Node.js

Step 3: Re-verify Node.js installation

• make sure to run this command on your terminal node -v then you will see your Node.js version.

Step 4: Installing n8n

• go to warp or terminal, type npm install -g n8n.
• Installation takes 3 – 5 mins approximately.
• After installation, Go to your terminal and type n8n to open.

• Now n8n is accessible via http://localhost:5678 or you can press “o” to open in your browser.
• After that make sure register an account, and verify it with your email-address.
• then you’re done.

Alright here’s the tips,

• To terminate the n8n from running, then you press ctrl + c on the terminal or warp, this will terminates and closes n8n for you.
• If you want to run n8n again, then go to terminal > type n8n.
• Maybe, you wanted to uninstall the n8n? write this command in your terminal / warp npm uninstall -g n8n

Installing n8n Locally With Docker

Docker is like a virtual container that packages an app and everything it needs to run into one neat box, so it works the same way on any computer. basically packaging the whole n8n into one container (Think it as a box), then you can use it on your computer. that is what it is.

For Docker, At least you need 4 GB of RAM (but, 8GB is recommended) I do have 20GB of RAM, and yet 3 GB taken for container. Most of the time it container stables around 1.7 – 2.0 GB of RAM.

Step 1: Install Docker

• Go to docker desktop link here, and click on Download Docker Desktop.
• Choose your operating system – Windows, Mac, Linux.
• You will get around approximately ~517 MB to download.
• Once download is completed, then install it on your directory.

Step 2: Creating Volumes on Docker Desktop

This is an essential step in install n8n, you can still directly install without volume on docker but data won’t persist. Think it like as a folder that stores all your credentials/workflows.

• Go to Volumes > Create a volume

• Name your volume as n8n-data and hit create

Step 3: Installing n8n Image on Docker Desktop

• Go to Images > Search images to run
• Search for n8nio/n8n (which comes under n8n’s domain and also has 100M+ downloads)
• Click on Pull

Step 4: Configuring n8n Image & Settings on Docker

• Click on the Play button
• Drop down optional settings

• Container Name, you can give any name you like this hello_docker or a random name will be generated.
• Ports – Enter Host Port -> 5678
• Volumes
  • Host path : n8n_data
  • Container path : /home/node/.n8n
• Now drop down to Environment variables.

• In Environment variables, you need to add 4 variables, so press + icon to create 3 more Environment variables.

• N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS = true
• N8N_RUNNERS_ENABLED = true
• GENERIC_TIMEZONE = Asia/Colombo
• TZ = Asia/Colombo
• Make sure to recheck everything is correct.
• Click on Run

Listen to this carefully, The generic time-zone, and TZ actual my timezone, You’ve to replace that value with your timezone. You can find your local timezone here.

• This is the interface you will get once the container starts to run.
• Editor now accessible via http://localhost:5678

Step 5: Configuring Your n8n Account

• Enter your information such as email, password, first name and all.

• Once you registering, then n8n will start sending a n8n license key to unlock selected paid features.
• Once you retrieved the license key, go to Settings > Usage and Plan > Enter Activation Key > Paste the activation key.

• you can see in docker container, mine is zealous_wilbur wherein license successfully activated in logs.

Yaay! finally installed on docker. Congratulations, that’s a solid wild ride. Now you know, how to access your n8n locally. Yes, I sense some questions coming out from your mind. I totally get it. I try to answer them below as a references for you, or else click here to post the question on our reddit-community.

Step 6: How to Stop n8n Container

• that’s pretty straightforward click on the Stop Icon in the container, and before stopping, make sure save your workflows.

The best practice: Save your workflow often, even when you made a small changes.

Essential Docker Commands for n8n

This is pretty much fun using docker with your terminal / warp because that gives you different vibe, and yeah in background a tech wiz soundtrack. that’s make you one.

docker ps -a

• docker ps only shows the running containers, and -a option include all the containers that exited, stopped or paused. that’s why you can see the zealous_wilbur has been exited 35 seconds ago.
• docker stop <container id> – This will stop the specific container that matches the ID.
• docker rm <container id> – this command will remove the container

My Thoughts

Take a moment appreciate yourself, you’ve came this far, You’re now running n8n locally. This means you have got no execution limits, and full control over your data, The hardest part is over, Now is the time to head back to http://localhost:5678 and start building automations.

If you’d any issue with the content, click here to comment on our reddit-post. This will help me to understand the issue and tackle by myself.

Credentials are similar to permission slips that let n8n access your accounts, and without any provided credentials, nodes can’t actually do anything with external services.

Here’s the complete roadmap of n8n for beginners

So basically you’ve to set them up at first then we can create workflow with app nodes easily.

• You’ve learned workflows and nodes, but now comes the real struggle, connecting to actual services.
• Every external service (Gmail, Slack, Sheets) needs authentication
• This guide shows you exactly how to connect the most popular services step by step.
• By the end, you’ll have Gmail connected and ready to automate.

Why n8n needs credentials?

• Services need to verify it’s really you making requests
• Protects your data from unauthorized access
• Each service has different security requirements

Prerequisites

Before you start setting up credentials in n8n, make sure you have,

1. A Google Account
   • You’ll need a Gmail account to access Google Cloud Console also known as GCC.
   • Use a dedicated account for automation if you’re working on business projects.
2. An n8n Instance
   • Self-hosted n8n running locally typically (http://localhost:5678)
   • or n8n Cloud account
   • Make sure you can access your n8n dashboard
3. Basic Understanding
   • Know what workflows and nodes are (covered in our previous posts)
   • Understand why you’re connecting these services

Google Cloud Console Setup (One Time + OAuth Consent Screen)

This is a very crucial step, you’ll only need to do this once for all google services (Gmail, sheets, maps, and etc)

Step 1 – Access Google Cloud Console

• Go to https://console.cloud.google.com/
• Sign in with your Google account

• Accept the Terms of Service and continue

Step 2: Create a New Project

• Click on the “Select a Project” button next to “Google Cloud”

• Click on New project
• Enter a project name, and click on create.

• You’ll receive a notification that project has been created

• Go to APIs & Services > OAuth consent screen
• Click on Get Started
• Provide any app name you prefer.
• User support email: click on the drop down and select your gmail address
• Click on next
• Audience: Select external. If you have a workspace account then you can select on internal
• Contact Information: Add your email address.
• Finish the setup by agreeing to the user data policy.

Step 3: Add Test Users

• Click Add users, and add your email address right there.

Step 4: Let’s Create an OAuth Client

• Go to Clients > Create a Client
• Select Application Type as Web Application
• Name your web client, Like “n8n client”
• For Authorized Redirect URIs: http://localhost:5678/rest/oauth2-credential/callback – Add this URL
• Click Create.
• A modal appears with Client ID and Client Secret, make sure to copy those values and save it on your desktop.

Alright, it’s time to add these credentials to n8n.

Gmail Credential Setup

Step 1: Enabling the Gmail API

• Go to Google Cloud Console > APIs & Services > Enabled APIs & Services

• Make sure to click on the Enable APIs and services

• Search for Gmail API

• Select the first result which is Gmail API by Google Enterprise API.

• Click on Enable the API.

• Go to Credentials section on the navigation

• In the credentials section, you can see that previously created OAuth 2.0 client ID while we creating the OAuth consent. Now click on the pencil icon to edit, then you will see the Client ID and the secret.
• Make sure to copy the both ID and secret.

Step 2: Adding the Credentials on n8n

• Go to your n8n dashboard > credentials section or Click on the dropdown and select Create credential

• Search for Gmail, and select Gmail OAuth2 API.

• Paste the Client ID and Client Secret

• Once you paste the ID and secret, then make sure to Sign in with Google. (sign-in with your gmail account that you have assigned as a test-user)

• Click on continue

• Now select all the access and continue, and you will receive a pop-up window says credentials successful.

• Even in your credentials are connected. so we can test it out whether everything is working fine.

Testing Gmail Connection

Let’s verify everything works by sending a test email.

Create a Test Workflow

• In your n8n dashboard, click Create workflow
• Add a manual trigger node (this lets you start the workflow manually)
• Add a Gmail node.
• Connect the Manual trigger to Gmail node

Configure Gmail Node

• In the Gmail node, select “Send a message” action.
• Fill in the fields
  • To: your own email address or any other email address owned by you for testing.
  • Subject: “Test from n8n”
  • Message: This is a test email from my n8n workflow!

Execute & Verify

• Click the Execute workflow
• Check the output – you should see labelIds:["sent"]
• Open your Gmail inbox.
• Look for the test email

Final Thoughts

Congratulations! You’ve successfully set up Gmail credentials in n8n, and sent your first automated email. Here’s what you accomplished.

• Configured Google Cloud Console – Created a project and set up OAuth consent screen (one-time setup for all Google services)
• Generated OAuth Credentials – Created Client ID and Client Secret for secure authentication
• Enabled Gmail API – Activated the Gmail API in Google Cloud Console
• Connected n8n to Gmail – Added credentials and authorized n8n to access your Gmail account
• Tested the Connection – Created and executed a workflow that sent a test email

You’ve cleared the biggest hurdle in n8n automation. From here, the possibilities are endless.

n8n is a powerful workflow automation tool that lets you connect different apps and services without writing complex code, and it’s simply a no-code platform. Think of it like a bridge between your favorite tools like slack, google sheet and etc.

When something happens in in one app, n8n can automatically trigger action in another.

Alright, What makes n8n unique? I say it’s flexibility, you can either use their cloud service or host it yourself (self-hosted) on your own server or local server.

Let’s get to the point.

This is part of my complete n8n beginner guide — where I cover everything from install to AI agents.

What is n8n Cloud?

Cloud n8n is the easiest way to get started. Simply create an account at n8n, and you’re ready to build automations within minutes. n8n handles all the technical stuffs and heavy liftings such as server maintenance, security updates, backups and scaling. You just need to focus on creating a workflow. that’s literally great isn’t it?

Click Here to Start with n8n Cloud

What is Self-hosted n8n?

Self-hosted n8n means you download the opensource software and run it on your own server. This could be AWS, Hostinger, Digital Ocean or even your local computer. You’re in complete control over your data, customization and scaling – but you’re responsible for keeping everything running smoothly, that’s all on you.

Alright, that’s great, now you know that what is what? and I hope you understood the difference between self-hosted and n8n cloud. Let’s see the comparisons, This is where we actually testing out the water in terms of everything.

Detailed Comparison Between Self Hosted & Cloud

Aspects	😶‍🌫️ Cloud	🖥️ Self-hosted
Cost	Subscription-based, starts free then scales with usage	Free software, but you pay for server hosting + maintenance time
Setup & Ease use	2 minutes to start, zero technical knowledge needed	Requires server setup, Docker knowledge helpful, 30-60 minute initial setup
Maintenance	Handled by n8n team	You handle updates, backups, security patches
Data Privacy & Security	Data stored on n8n’s servers	Complete data ownership, runs behind your firewall
Customization	Standard features only	Full access to customize, add custom nodes
Scalability	Automatic scaling handled by n8n	You manage server resources and scaling
Support	Email support, community	Community-only (free), or enterprise support (paid)

When to Choose n8n Cloud?

Cloud n8n is maybe perfect choice for many users and organizations. I also starts with a n8n cloud and obtained the first 14 days free trial. Well, here are the key scenarios where the cloud may come in handy for you. Just try to put yourself in these below buckets?

1. You’re New to Automation and Wants to Start Quickly

If you’re just beginning your automation journey, cloud n8n removes all the technical barriers. There is no need to understand servers, hosting and deployment process. Simply visit this n8n, as I stated above, register it and then start your workflow simple as that.

The cloud platform also provides a gentler learning curve because you only need to think about creating an automation.

2. You Have a Small Team Without IT Resources

Not every business has a dedicated IT department or tech wiz. If you’re team consists primarily of marketers, growth specialists, sales people, customer support agent, or other non-technical roles, ahem. then Cloud is the best bet for you.

3. You Want a Predictable Monthly Costs

Cloud n8n operates a transparent execution-based pricing model, making it easy for you to forecast a predictable monthly automation cost. Unlike other automation sites that charge per tasks or operations.

n8n charges based on the complete workflow execution which means one workflow run counts as execution regardless of how many step it contains (or nodes).

Aye, now I hope you could easily put yourself in these above buckets, and let’s head to the n8n cloud pricing model.

Current n8n Pricing Model (2025)

n8n generously offers 14-days free trial with no credit card required, so you can test the platform risk free. After that you can consider these plans.

Starter Plan: $20/month

• 2,500 workflow executions per month.
• Unlimited workflows, users and steps
• Perfect for individual and small teams getting started
• Email support included.

Pro Plan: Starting at $50/month

• 10,000 workflow executions per month (scales up to 50,000 executions for $120/month)
• Everything in Starter Plan.
• Best for growing teams with moderate automation needs

Enterprise Plan: Custom Pricing

• Unlimited exeuction.
• 365 days of insights.
• Dedicated support with SLAs
• Custom integrations
• Advanced Security Features
• For large organizations with mission critical workflows.

I should appreciate n8n because of their transparency and no hidden costs, Your monthly bill is actually straightforward, no surprise charges for infrastructure, maintenance, security patches, or SSL certificates. Everything is included in the subscription.

Let’s say you’re a small marketing agency running

• 3 workflows that sync leads from your website to CRM (Triggered ~50 times/day) = 1500 executions/month.

• 2 daily scheduled workflows for social media reports = 60 executions/month
• 1 workflow that processes customer feedback form (~15 per day) = 450 executions/month

Total: ~2010 executions/month = This fits comfortably within the starter plan at $20/month. You know your exact cost, and as your agency grows, you can easily track when it’s time to Upgrade to PRO.

When to Choose Self-hosted?

Self-hosted n8n gives you complete ownership and control over your automation infrastructure. While it requires technical knowledge to configure it. Here’s when self-hosted makes most sense.

1. You Need Complete Data Control and Privacy

in Self-hosted, your data never leaves your infrastructure whether it in a dedicated server or your local computer. so basically, Every workflow executions, every piece of customer information stays with you and your infrastructure.

2. You’re In a Regulated Industry

Regulated industries like Healthcare, finance and government sectors often have strict compliance requirements that makes self-hosting not just a preferrable option but mandatory.

3. You Have a Technical Experts In-House

Ideally, you have someone on your team who comfortable with DevOps such as maintaining the server, monitoring, docker containerization, troubleshooting technical issues.

For companies building technical teams, self-host n8n can also serve a valuable learning experience. Your team gets hand-on experience with modern automation platform, and infrastructure management – Skills that benefits your organization beyond.

4. Community Support

While you won’t have a dedicated professional support on the free community, n8n has an active community forum with over 45k members, ready to help you troubleshoot issues and share solutions. If you need a guaranteed support, the self-hosted Business and Enterprise plan offers SLAs and direct access to n8n’s team.

5. You’re Running High-Volume of Workflows (Cost-effective at Scale)

Here’s where the economy of self-hosted shines, At low volumes, cloud n8n is often cheaper – but as your automation scales, self-hosting becomes significantly more cost-effective.

Let’s compare them with actual VPS from Hostinger

• Starter Plan: 2,500 executions/month = $20/month
• Cloud Pro Plan: 10,000 executions/month = $50/month
• Cloud Pro Plan: 50,000 executions/month = $120/month

Self hosted on Hostinger VPS – Hostinger offers VPS hosting specifically optimized for n8n starting at $4.99/month that makes easy n8n installation with pre-configured Ubuntu template and docker setup that just takes you few clicks.

• KVM 1 – $4.99/month (1 vCPU, 4GB RAM, 50GB NVMe) – Good for light workflows
• KVM 2 – $6.99/month (2 vCPU, 8GB RAM, 100GB NVMe) – Recommend starting point for all users
• KVM 3 – $9.99/month (4 vCPU, 16GB RAM, 200GB NVMe) – For complex workflows.

Alright let’s look at the practical examples, because I always wanted to give you some extra clarification. Let’s split up to 3 scenarios

	10k executions/mo	50k executions/mo	200k executions/mo
Cloud Plan	Cloud Pro Plan	Cloud Pro Plan	Enterprise Plan
Cloud Cost	$50/mo	$120/mo	$500+/mo
Self-host Plan	Hostinger KVM 2	Hostinger KVM 2	Hostinger KVM 2
Self-host cost	$6.99/mo	$6.99/mo	$9.99/mo
Monthly Savings	$43/mo	$113/mo	$490/mo
Yearly Savings	$516/year	$1356/year	$5880+/year

Maybe you would think like this? Can I use n8n + Hostinger directly without going to n8n cloud. YES! you can do this as well. For an instance, assume that you have already a KVM1 server.

• Hostinger KVM 1 : $4.99/month = unlimited executions
• n8n Cloud: $20/month = only 2,500 executions

Even with just 1,000 executions/month, You’re saving $15/month ($180/year) with Hostinger.

My Honest Recommendation for Small Workflows

Choose Hostinger if,

• You’re comfortable with basic tech (or willing to learn)
• You want to save money in long-term
• You might scale up later.
• You have few hours to set it up properly.
• Your workflows might grow beyond 2,500 executions

Choose n8n cloud if,

• You’re completely non tech-related.
• You need automation TODAY (urgency matters)
• Your value simplicity over savings
• You don’t want maintenance responsibility
• You’re under 2,500 executions and will stay right there.

ASK Yourself – “Is Savings $180/year worth spending 2-3 hours on initial setup?“

• If YES – Go to Hostinger
• if No – Start with Cloud

My Final Thoughts

Choose n8n Cloud if you want zero setup, have limited technical skills, or run under 10,000 executions monthly—pay $20-50/month for complete peace of mind. Choose self-hosted (Hostinger) if you’re comfortable with basic tech and want unlimited executions for under $10/month, especially beyond 10,000 runs where savings multiply. Not sure? Start with cloud’s free trial to learn n8n, then migrate to self-hosted once comfortable. Either way, you’re getting one of the most cost-effective automation platforms available.