Blog

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.

In this post, I’m going to teach you how to handle API rate limits in n8n like a pro. Maybe you’re a beginner to this space, well, no worries. I’ve got you covered everything you need to know in terms of handling API rate limits.

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 in creating your first workflow, that was specifically crafted for beginners. Now, we are going explore workflows, nodes and data-flow.

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)

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: Complete Guide to Triggers, Actions, & Logic

• 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.

Read : n8n nodes & data flow

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.

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.

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.

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. 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.