Build an n8n AI Agent with LangChain & MCP

What if every repetitive question, every manual lookup, and every tiny calculation could be handled for you, in the background, by an AI Agent that you control? The “MCP Learning” n8n template is designed to be that turning point. It connects a chat trigger, an AI Agent powered by LangChain and OpenAI, and a set of reliable tools (Calculator, HTTP requests, and an MCP client) so you can move from doing tasks yourself to orchestrating them with automation.

This guide walks you through that journey. You will start with the problem of scattered, manual work, shift into what becomes possible when you adopt an automation mindset, then learn how this n8n template gives you a practical, ready-to-use pattern you can adapt and grow over time.

The problem: manual tasks stealing your focus

Most teams face the same bottlenecks. A customer asks a question, and you jump into a system to check an order. A colleague wants a quick calculation, and you reach for a spreadsheet. An internal request appears, and you manually trigger an API call or microservice. Each action seems small, but together they drain time and attention that could be spent on strategy, creativity, or growth.

AI and automation can help, but only if they are connected in a safe and structured way. You need something that can:

• Listen to real chat messages and act on them
• Use a powerful LLM like OpenAI to understand intent
• Call tools in a controlled, auditable way
• Keep side effects isolated and traceable

This is exactly where the “MCP Learning” n8n workflow template comes in. It is not just a demo, it is a reusable pattern that you can apply to customer support, internal operations, and any workflow that benefits from an AI agent with real tools at its disposal.

Mindset shift: from doing the work to designing the system

Adopting automation is not only about technology, it is about mindset. Instead of asking, “How do I respond to this request?” you start asking, “How can I design a system that responds for me, safely and reliably?”

With n8n, LangChain, and MCP, you are not building a one-off chatbot. You are building an AI Agent that:

• Understands natural language through an OpenAI Chat Model
• Plans actions using LangChain agent logic
• Calls well-defined tools like a Calculator, HTTP Request, or MCP Client
• Executes side effects in a separate, controlled flow using an MCP Server Trigger

This template encourages you to think like an architect of your own workflows. You define which tools are available, you set the rules, and you decide how far the agent can go. Every improvement you make compounds over time, freeing more hours and mental energy for the work that actually moves you or your business forward.

The n8n AI Agent template: your starting point

The “MCP Learning” template shows a modern way to orchestrate AI inside n8n. It connects:

• A chat trigger that starts the workflow when a message is received
• An AI Agent node powered by LangChain logic
• An OpenAI Chat Model for language understanding and generation
• Tools like a Calculator, HTTP Request, and MCP Client that the agent can call
• An MCP Server Trigger that handles those MCP tool calls on a separate flow

Once set up, you can send a message to your chat entry point, watch the agent interpret it, decide whether it needs to call a tool, and then respond with a clear, verifiable answer. It is a powerful pattern that you can adapt to fit your specific use cases.

How the workflow behaves: from message to meaningful action

To understand the transformation this template enables, it helps to walk through the full journey of a single message:

1. A user sends a chat message. This could be from a webhook or any supported platform integration.
2. The message lands in the When chat message received node, which triggers the workflow and passes the content onward.
3. The AI Agent node receives the message. Using LangChain logic and the configured OpenAI Chat Model, it interprets the user’s intent and plans its next steps.
4. If the agent decides it needs extra information or a precise operation, it calls one of the tools available to it, such as:
   • Calculator for deterministic numeric calculations
   • HTTP Request (Tool) to reach external APIs or microservices
   • MCP Client to interact with tools managed via MCP
5. Tools run in isolation. When the MCP Client is used, the request is handled by a separate flow that starts from the MCP Server Trigger. This trigger receives the tool call, executes the required action, and returns the result.
6. The AI Agent gathers the tool outputs, composes a final response, and sends it back to your chat platform or any downstream system you connect.

The result is a loop where your AI Agent not only talks, but acts. It can compute, fetch data, and perform side effects in a controlled, observable way.

Node-by-node: what powers this template

When chat message received

This node is the entry point. It listens for incoming chat events, either via webhook or a platform-specific trigger. Every user message that reaches this node becomes a potential automated interaction handled by your AI Agent.

AI Agent

The AI Agent node is the coordinator of the entire experience. It:

• Receives the incoming chat message
• Runs your LangChain agent logic for planning and tool selection
• Decides when to call tools and how to combine their outputs
• Generates a final response for the user

In n8n, this node integrates directly with LangChain, connecting the chat model and your tool set into one cohesive agent behavior.

OpenAI Chat Model

The OpenAI Chat Model node provides the language intelligence. In the template, it is configured with a modern model such as gpt-4.1-nano, but you can choose the model that fits your needs and budget.

Before you enable this node, make sure your OpenAI credentials are correctly configured in n8n under Credentials → OpenAI API Key. This step unlocks the LLM that powers understanding, reasoning, and natural language responses.

MCP Client & MCP Server Trigger

The MCP pair is what makes structured tool orchestration possible. They work together as a client-server pattern inside your automations:

• MCP Client appears to the AI Agent as a tool it can call. When chosen, the agent sends its request through this client.
• MCP Server Trigger runs in a separate n8n flow. It listens for incoming MCP tool calls, executes the desired action, and returns the result.

This separation lets you run tools in isolation, keep side effects under control, and centralize how tool calls are logged and monitored. It is a scalable pattern for safe, auditable AI-driven actions.

Calculator

The Calculator node is a simple but powerful example of a deterministic tool. Instead of asking the LLM to approximate a calculation, the agent calls this node to perform exact numeric operations. This keeps results auditable and reduces the risk of hallucinated numbers.

HTTP Request (Tool)

The HTTP Request node, configured as a tool, lets your agent talk to the outside world. It can:

• Send GET or POST requests
• Call internal microservices or external APIs
• Trigger background jobs or workflows in other systems

In the template, it serves as a hook for richer automations, like checking order statuses, updating records, or kicking off internal processes.

Getting started: bring the template into your n8n space

To turn this pattern into something you can test and customize, follow these steps in your own n8n instance:

1. Import the template JSON Go to Workflow → Import from JSON and paste or upload the template file.
2. Configure OpenAI credentials In Credentials, add or update your OpenAI API Key, then link it to the OpenAI Chat Model node.
3. Set up the chat trigger Configure the webhook URL or connect the trigger to your chat platform integration so that incoming messages can reach the workflow.
4. Align MCP settings Double check the MCP Server Trigger webhookId and the MCP Client sseEndpoint. Update them so they match your MCP deployment or local test instance.
5. Adjust HTTP Request parameters If you plan to call specific APIs, customize the HTTP Request node body, headers, and endpoints to match your services.
6. Activate and test Turn the workflow on, send a few sample messages, and watch how the agent calls tools and responds.

Within a few minutes, you will have a working AI Agent in n8n that you can observe, refine, and extend.

Best practices to keep your AI Agent safe and reliable

Security and credentials

Security is part of building mature automation. To keep your workflows safe:

• Never hard-code API keys or tokens in workflow JSON
• Use n8n Credentials to store secrets securely
• Restrict the HTTP Request tool to trusted endpoints
• Implement authentication and authorization where possible

Tool design

The more deterministic your tools are, the more predictable your agent becomes. Ideal tools include:

• Calculators and numeric operations
• Lookups against internal databases or APIs
• Authenticated HTTP calls with clear input and output formats

This approach minimizes hallucinations and makes debugging far easier.

Agent prompts and safety

Strong system prompts are your guardrails. Use them to define:

• The scope of what the agent should and should not do
• Which tools it may call and in what situations
• How it should refuse or escalate unsafe or unclear requests

For tools with side effects, consider adding a verification step. For example, you can require explicit confirmation from the user or a structured request format before the agent calls a tool that changes data or triggers external actions.

Observability and auditing

To grow your automation confidently, you need visibility into what the agent is doing. Combine:

• Logs of all tool calls and agent plans
• Model responses captured in n8n
• The MCP Server Trigger pattern, which centralizes tool execution logs
• n8n’s execution history for a full audit trail

This makes it much easier to troubleshoot, improve prompts, and demonstrate that your AI workflows are behaving as intended.

Real-world use cases: where this template can take you

Once you understand the pattern, you can apply it to many scenarios. A few common examples include:

• Customer support assistants that compute refunds, check order statuses, or call backend APIs for account information
• Automated data enrichment that uses HTTP tools to fetch external records and update your internal systems
• Internal automation for scheduling tasks, running computations, or handling form submissions without manual intervention

Each new use case builds on the same foundation: a chat trigger, an AI Agent, and a set of well-designed tools.

Troubleshooting common issues

Agent not responding

If the agent seems silent, check:

• That the chat trigger webhook or platform integration is correctly configured
• That your OpenAI credential is valid and linked to the Chat Model node
• That the AI Agent node is pointing to the correct model configuration

Tool calls failing

When tools fail, start with visibility:

• Inspect node execution logs in n8n for errors
• Verify that endpoints, authentication headers, and payloads in the HTTP Request node are correct
• For MCP-related issues, confirm that SSE and server endpoints are reachable and that webhookId values match between the MCP Client and MCP Server Trigger

Extending the template into your own automation system

This template is intentionally designed as a foundation. Once it is running, you can expand it step by step:

• Add new tools for database queries, calendar APIs, or internal microservices
• Extend the LangChain configuration with memory, multi-step planning, or custom tool logic
• Introduce persistent memory nodes to support longer, context-aware conversations
• Implement rate limiting and retry logic for external APIs
• Include validation and sanitization steps for user inputs before they reach critical tools

Each enhancement brings you closer to an automation ecosystem where your AI Agent becomes a trusted collaborator, not just a novelty.

Demo prompts to explore and experiment

Once the template is active, try messages like these to see the tools in action:

• “Calculate the monthly payment for a $20,000 loan at 5% over 60 months.” This should invoke the Calculator tool for a precise result.
• “Check status of order 12345 and notify me if it’s delayed.” This can trigger an HTTP Request to your order API and return a status.
• “Please schedule a follow-up email in three days if the client doesn’t respond.” This can be wired to an internal scheduling API or microservice.

Use these as a starting point, then adapt them to your own data, systems, and workflows.

From template to transformation

The “MCP Learning” n8n template is more than a sample workflow. It is a practical, extensible pattern for building safe, auditable AI-assisted automations with LangChain and OpenAI. By separating language understanding in the LLM and Agent from deterministic tool execution through Calculator, HTTP, and MCP, you gain both flexibility and control.

As you refine prompts, design better tools, and add new integrations, this pattern can grow with you. It can support customer-facing bots, internal automations, and hybrid human-AI workflows that save time, reduce errors, and free your team to focus on what matters most.

Take the next step

If you are ready to move from manual tasks to designed systems, now is the moment to experiment. Import the template into your n8n instance, connect your OpenAI credentials, and try the demo prompts. Watch how the agent behaves, then iterate.

Use this template as a stepping stone toward a more automated, focused workflow. With each improvement, you will build an AI-powered automation layer that supports your goals instead of distracting from them.

If you want help adapting the template to your

Turn Your Newsletters into Daily Twitter Threads (Without Losing Your Mind)

If you have ever copied chunks of your newsletter into Twitter, chopped them into 280-character bits, fixed broken links, rewrote the hook, then did it all again tomorrow, this guide is your new best friend.

Instead of manually turning long-form content into Twitter (ok, X) threads every day, you can let an n8n workflow and an LLM do the heavy lifting. You keep the editorial judgment and final say, the robots handle the repetitive stuff that slowly erodes your will to create.

Below is a practical, production-ready setup that combines:

• n8n automation
• An LLM via LangChain or a provider like Anthropic Claude Sonnet
• Structured output parsing so the thread format does not implode
• Slack publishing for human review before anything hits X

The result: reliable, daily Twitter threads from your newsletter with minimal manual effort and maximum control.

Why Turn Newsletters into Twitter Threads Anyway?

Your newsletter is already doing the hard work: curated links, original insights, commentary your audience actually cares about. Letting that live in inboxes only is like writing a book and then hiding it in a drawer.

Repurposing newsletters into Twitter threads helps you:

• Boost reach by surfacing long-form ideas into fast-moving social feeds.
• Bring new people in by driving traffic back to your newsletter and site.
• Reuse what you already have instead of inventing new social content from scratch every day.

In other words, you get more output from the same input, without more caffeine or extra interns.

What This n8n Workflow Actually Does

This workflow mimics the core automation pipeline used by modern newsletters to publish daily news threads. Here is the high-level flow:

1. Take in your newsletter content using a trigger that fits your stack.
2. Feed the model examples of how you like your threads written.
3. Build a precise prompt that tells the LLM exactly how to structure the thread.
4. Call the LLM using LangChain or a provider node such as Anthropic Claude Sonnet.
5. Parse the model output into clean, numbered tweets.
6. Send the draft to Slack for editorial review, edits, and scheduling.

So instead of wrestling with character limits and formatting, your team just reviews, tweaks, and approves.

Meet the n8n Nodes Behind the Magic

The sample n8n template uses a handful of nodes, each doing a very specific job so the whole pipeline stays predictable and maintainable.

• workflow_trigger – Entry point where your newsletter content arrives.
• set_examples – Stores thread examples and style guidance for the LLM.
• build_prompt – Combines newsletter text with your prompt template.
• write_twitter_thread – Calls the LLM via LangChain or a provider node like Anthropic Claude Sonnet.
• twitter_parser – Parses the LLM response into a structured, tweet-by-tweet format.
• set_result – Saves the final thread text into the workflow payload.
• share_twitter_thread – Posts the draft thread to Slack for your editors and schedulers.

Each node does one thing well, which makes debugging a lot easier when something inevitably goes off script.

Step-by-Step: Build the Newsletter-to-Twitter Workflow

Let us walk through the setup from start to finish. You can adapt the details to your tech stack, but the structure stays the same.

1. Choose How the Newsletter Enters n8n (Trigger & Input)

First, decide how the workflow gets your newsletter content. A few common options:

• Manual trigger so editors can paste the final copy directly.
• Webhook that receives HTML or text from your CMS once the newsletter is ready.
• Scheduled trigger that pulls the latest edition from storage like S3 or Google Drive.

Pick the one that matches how your newsletter is produced today, not your fantasy future stack.

2. Teach the LLM Your Thread Style (Provide Examples)

LLMs are powerful, but they are not mind readers. Your set_examples node is where you spoon-feed them your preferred style.

In this node, include:

• 2 to 3 examples of high-performing threads from your brand or niche.
• Short, numbered tweets that are informative and easy to skim.
• Guidance like:
  • “Use numbered tweets (1/ …)”
  • “Bold key terms”
  • “Keep paragraphs short”

Think of this as onboarding a very fast junior social media editor.

3. Build a Clear, Bossy Prompt

Next up, the build_prompt node. This is where you merge the newsletter text with a prompt template that tells the model exactly what to do.

Your prompt should instruct the LLM to:

• Select the top 4 to 8 news items from the newsletter.
• Write a strong hook tweet followed by a numbered thread (1/ – N/).
• Use line breaks, minimal emojis, and include @mentions for well-known businesses when referenced.
• Preserve URLs exactly as they appear in the newsletter.
• Finish with a CTA that links back to your newsletter, for example https://recap.aitools.inc.

The more explicit you are here, the fewer surprises you will get in the output.

4. Call the LLM with LangChain or Provider Nodes

Now it is time to let the model cook. In the write_twitter_thread node, you call your chosen LLM through LangChain or a provider-specific n8n node.

In the example template, Claude Sonnet 4 is used, but you can swap in your favorite model. A few key settings to configure:

• System role that defines the persona, for example:
  “expert AI tech communicator and social media editor.”
• Max tokens so the model does not produce a novel instead of a thread.
• Temperature between 0.0 and 0.4 for more deterministic, less chaotic output.
• Inline inclusion of your prompt examples to keep style consistent.

Set it up once, then let the node quietly do its job in the background every day.

5. Parse the Thread into Clean Tweets

LLM output is naturally free-form, which is charming until you try to schedule it programmatically. The twitter_parser node fixes this.

Use a structured output parser, such as:

• A JSON schema that defines the expected fields, or
• A regex-based node that extracts the numbered tweets

This lets you:

• Split the thread into individual tweets automatically.
• Catch stray formatting, unexpected characters, or markup that might break the thread.
• Keep the output predictable enough for review and scheduling tools.

The parsed result is stored by the set_result node so the rest of the workflow can use it cleanly.

6. Keep Humans in the Loop with Slack QA

Even the best automation should not have direct access to your social accounts without a human sanity check. That is where the share_twitter_thread node comes in.

This final node posts the full thread into an editorial channel in Slack (or similar) along with a permalink back to the original newsletter. Your editors can then:

• Verify that facts and quotes are accurate.
• Check that links and @mentions are correct and not hallucinated.
• Edit copy, tighten hooks, and give the final approve-to-publish signal.

You get the speed of automation without the “why did the bot tag the wrong account” headaches.

Prompt Engineering Tips for Reliable Twitter Threads

A few tweaks to your prompts can make the difference between a clean, on-brand thread and something that looks like it escaped from a prompt playground.

• Always ask for a header tweet with a clear hook and context, for example:
  “TODAY’S AI NEWS: …”
• Force URL fidelity by telling the model to copy external links exactly as provided.
• Limit tweet length with instructions such as:
  “No tweet > 250 characters”
  to keep things readable and leave room for quote tweets and comments.
• Use @mentions carefully. Specify that mentions should only be used for known accounts explicitly referenced in the newsletter to reduce hallucinations.
• Define formatting rules, such as:
  • Numbered tweets
  • Bold for emphasis
  • Markdown or plaintext depending on your publishing destination

Be specific, be repetitive, and do not assume the model will “just know” what you want.

Handling Edge Cases and Staying Safe in Production

Once this workflow is running daily, you will want it to be boringly reliable. That means handling the weird stuff up front.

• Hallucinated links or quotes
  Flag any external URLs that were not in the original newsletter so editors can double-check before publishing.
• Sensitive or private data
  Sanitize PII and anything confidential before sending content to the model.
• Rate limits and retries
  Implement exponential backoff or queueing for LLM API calls, especially if you are running multiple newsletters or high volume.

A little defensive engineering here saves a lot of late-night debugging later.

Testing the Workflow Before Full Rollout

Instead of flipping the automation switch for everything on day one, treat this like any other experiment.

• Run an A/B test:
  • Half of your threads created manually
  • Half generated by the n8n + LLM workflow
• Measure:
  • Engagement uplift on X
  • Click-through rate back to the newsletter
  • Error rate, for example how many manual edits per automated thread

Use the results to refine your prompts, examples, and parsing until the automated threads perform at least as well as your hand-crafted ones.

What This Looks Like with Real Content

Here is a short newsletter excerpt that this workflow can turn into a full thread:

“AI models from Google and OpenAI achieved gold medal performance at the International Mathematical Olympiad, solving five of six problems with human-readable proofs. A separate incident highlighted risks: an AI coding assistant deleted production data, underscoring the need for guardrails.”

From this, the LLM should produce a 6 to 8 tweet thread that includes:

• A hook tweet summarizing “today in AI” style news.
• Bullets or tweets detailing the IMO achievement and what it means.
• A cautionary note about AI agents and production data risks.
• A closing CTA inviting readers to subscribe to the full newsletter.

All of that without you manually trimming sentences to fit the character limit.

What Success Looks Like When This Is Live

Once the pipeline is humming along, you should start to see:

• Faster social distribution for each new newsletter edition.
• More referral traffic from X back to your newsletter signup page.
• Less manual grunt work for your social team, while still keeping editorial control via Slack review.

You get the consistency of automation plus the polish of human editors.

Quick Setup Checklist: From Zero to Automated Threads

Ready to try this with your own newsletter? Here is a simple path to get started:

1. Clone or build the n8n workflow and connect your LLM credentials (Anthropic, OpenAI, or similar).
2. Create 2 to 3 example threads that match your brand voice and add them to the set_examples node.
3. Configure the parser node with a simple JSON schema such as:
   {"twitter_thread": "string"}
   to extract the full thread from the model output.
4. Route the final output to Slack in an editorial channel where your social team can review, edit, and schedule.

Next Steps and Where to Get the Template

If you are ready to stop hand-crafting every thread and want a daily stream of high-impact Twitter content from your newsletter, this workflow is a solid starting point.

Try it with your next edition, monitor engagement, and iterate. For more workflows, prompts, and automation templates, subscribe at https://recap.aitools.inc and request the n8n template so you can get up and running quickly.

n8n GraphQL Projects Template Explained

This article provides an in-depth explanation of an n8n workflow template that integrates with an AppSync GraphQL Projects API. The workflow is designed to query project data, support AppSync-style pagination with nextToken, merge multiple input sources, and adapt its behavior based on incoming parameters. If you operate n8n in a production or near-production environment and need a robust pattern for querying GraphQL endpoints, this guide breaks down the complete node structure, data flow, and recommended improvements.

Use Case and Core Capabilities

The primary objective of this template is to automate the retrieval of project records from a GraphQL API in a controlled and reusable way. It is optimized for scenarios where workflows must:

• Accept multiple input sources, such as a triggering workflow and a temporary session file
• Combine those inputs into a single, coherent request payload
• Handle AppSync pagination using nextToken
• Apply conditional logic and post-processing based on response data

The result is a pattern that can be dropped into broader automation chains to reliably fetch and normalize project data for downstream processing, reporting, or synchronization tasks.

High-Level Workflow Architecture

At a conceptual level, the workflow executes the following sequence:

1. Receives parameters from a parent workflow through an Execute Workflow Trigger
2. Reads a JSON session or authentication file from disk
3. Parses the file content to extract the authentication token and related metadata
4. Deletes the temporary file for security and housekeeping
5. Merges all input sources into a single item
6. Executes a ListProjects GraphQL query against the AppSync endpoint
7. Evaluates the presence of nextToken to determine if additional pages exist
8. Prepares variables for subsequent paginated calls when required
9. Aggregates all pages into a unified result set using a Code node

Trigger and Input Handling

Execute Workflow Trigger – Entry Point

The workflow is not intended to run in isolation. It is initiated by another n8n workflow through the Execute Workflow Trigger node. This node typically receives parameters that influence the GraphQL query, such as:

• fileName – the name of the session or token file to read
• status – a filter for project status
• name – a filter for project name or partial match

These fields are later mapped into GraphQL variables and filters, which allows the calling workflow to dynamically scope which projects are retrieved.

Reading and Parsing Session Data

Read/Write Files from Disk

The next step is to load session-related information from disk. The Read/Write Files node reads a JSON file that contains session data, such as an auth_token. The file path is not hardcoded. Instead, it uses the fileName provided by the trigger or a fallback default.

This pattern is useful for short-lived credentials or tokens that are generated by an upstream process and persisted only for the duration of a single workflow execution.

Extract from File

Once the file has been read, the Extract from File step parses the JSON content and exposes individual fields as structured data within n8n. For example, the auth_token is extracted and made available to subsequent nodes so that the GraphQL request can set a dynamic Authorization header.

Secure Cleanup of Temporary Files

Execute Command

To avoid leaving sensitive material on disk, the workflow executes a shell command using the Execute Command node:

rm -rf {{ $json.fileName }}

This deletes the temporary session file after it has been read and parsed. While this is effective for cleanup, it must be used with caution. Filenames should always be validated or sanitized to mitigate the risk of command injection or accidental deletion outside the intended directory.

Unifying Inputs Before the GraphQL Call

Merge Node – Combining Multiple Sources

The workflow then uses an n8n Merge node to consolidate data from three different branches:

• The initial trigger input (status, name, fileName, and any other parameters)
• The parsed session data from the JSON file (for example auth_token)
• The output of the command execution (if any relevant metadata is returned)

The Merge node is configured in combineByPosition mode, which aligns items from each input by index and merges their fields into a single item. This unified item is then used as the source of truth for the GraphQL node, ensuring all necessary variables and headers are available in one place.

GraphQL Integration With AppSync

ListProjects (GraphQL) Node

The core integration point is the ListProjects GraphQL node, which calls an AppSync endpoint with a ListProjects query. Key characteristics of this node include:

• The query requests a comprehensive set of nested fields, such as project squads, client details, tags, and meetings.
• GraphQL variables are constructed dynamically. If status or name are present in the merged input, they are included in the query filter. If they are omitted, the query runs without those constraints.
• The Authorization header is populated using the auth_token extracted from the JSON session file. n8n expressions are used to inject this token into the node configuration at runtime.
• The limit parameter is set to 999 to retrieve a large batch of projects per page. AppSync still returns a nextToken when more results are available, so subsequent pages can be fetched.

Pagination Logic and Control Flow

Conditional Routing Based on nextToken

If1 Node – Pagination Check

After each GraphQL request, the workflow needs to determine whether additional pages exist. This is handled by an If node that inspects the nextToken field in the GraphQL response.

• If nextToken is empty or null, the workflow follows the true branch. This indicates that the current response already contains the final page of results.
• If nextToken is present, the workflow follows the false branch, which prepares a new request cycle for the next page.

Edit Fields (Set Node) for Subsequent Pages

When pagination needs to continue, the Edit Fields (Set) node on the false branch constructs the parameters required for the next GraphQL call. It explicitly sets:

• nextToken – taken from the current GraphQL response
• auth_token – preserved from the initial session data
• status and name – forwarded from the original input to maintain consistent filters across pages

These fields are fed back into the ListProjects node, allowing the workflow to request the next page of results using the same filter criteria and authentication context.

Aggregation of Paginated Results

Code Node – Pagination Collector

The final step in the pagination process is to consolidate all pages into a single coherent output. A Code node is used to:

• Iterate over the outputs of both branches of the If node across multiple executions
• Collect each project item from every GraphQL response
• Stop once no nextToken is present on any branch, indicating that all pages have been retrieved

The Code node effectively implements a do/while-style loop over the paginated responses. It assumes that n8n is configured to provide branch outputs as separate streams, which can be indexed by page index. The final output of this node is a unified array of project objects that can be consumed by downstream workflows.

How AppSync Pagination Is Implemented

AppSync uses a nextToken mechanism for pagination. The template encapsulates this pattern as follows:

• Each GraphQL request includes a nextToken variable when one is available from the previous response.
• The If node evaluates the presence of nextToken after each call.
• The Code node walks through the results of each iteration, aggregating items and checking for termination conditions.

This architecture gives you clear separation between the responsibilities of querying, branching, and aggregation, which is beneficial when you need to debug or extend the workflow.

Security, Reliability, and Best Practices

Security Considerations

• Avoid storing long-lived secrets on disk. Temporary files should be used only for short-lived session data and must be deleted promptly, as this template does using the Execute Command node.
• Always sanitize and validate filenames before passing them to shell commands. This reduces the risk of command injection and unintended file operations.
• Limit the exposure of sensitive tokens in logs, error messages, and node output where possible.

Reliability and Rate Limiting

• GraphQL or AppSync endpoints may enforce rate limits. Even with a high limit value such as 999, you may need to introduce delays or backoff strategies to avoid throttling.
• Use the built-in retry configuration on the GraphQL or HTTP Request node to automatically handle transient errors such as 5xx or 429 responses.
• For critical automations, consider adding global error handling via an Error Trigger workflow to capture and respond to failures consistently.

Recommended Enhancements and Customization Options

Retry and Backoff Strategies

For production workloads, you should wrap the GraphQL call with a resilient error handling pattern. Options include:

• Configuring node-level retries with exponential backoff for network or rate limit errors
• Using an Error Trigger to route failed executions to a remediation workflow

Refining the Pagination Pattern

If you prefer a different approach to pagination, you can:

• Implement an explicit loop using the n8n “Execute Workflow” pattern where each iteration calls the same workflow until no nextToken is returned.
• Use a webhook or function-based iterative loop that performs repeated HTTP requests from a single Code node.
• Extract the pagination logic into a dedicated Function/Code node that is responsible solely for iterating until nextToken is absent.

More Secure Credential Management

While the template demonstrates reading an auth_token from disk, a more secure and maintainable approach is to use n8n Credentials or an OAuth2 integration if your GraphQL backend supports it. This provides:

• Centralized management of tokens and secrets
• Reduced reliance on temporary files
• Better alignment with security and compliance requirements

Optimizing Response Size and Performance

The reference query requests many nested fields. In performance-sensitive environments, you should:

• Request only the fields that are strictly required by downstream systems
• Reduce payload size to lower bandwidth usage and improve response times
• Consider lowering the limit if your endpoint is sensitive to large result sets

Troubleshooting and Diagnostics

• Empty results: Verify that the Authorization header is correctly set and that the token is valid and not expired.
• Infinite or unexpected pagination: Temporarily log or inspect nextToken values to ensure the API is returning valid tokens and that the Code node logic is correctly detecting termination.
• File deletion issues: If the Execute Command node fails, check file paths, permissions, and the working directory used by the node.
• General debugging: Use n8n’s Execution view to inspect node outputs step by step. This is particularly useful for catching misconfigured expressions, missing fields, or incorrect merge behavior.

When This Template Is a Good Fit

Consider using this n8n GraphQL Projects template when you need to:

• Retrieve large lists of projects from an AppSync or similar GraphQL endpoint
• Combine parameters from a triggering workflow with session data stored in a temporary file
• Handle GraphQL pagination and return a single, merged collection of project records

Pre-Production Checklist

1. Move authentication tokens and secrets into n8n Credentials or an external secret manager instead of disk-based session files.
2. Validate and sanitize any filenames passed into the Execute Command node, and confirm that file paths are correct.
3. Review and adjust the GraphQL query, including requested fields and limit, to meet your performance and data requirements.
4. Implement an appropriate error handling and retry strategy to address rate limiting and transient network issues.

Conclusion

This n8n GraphQL Projects template provides a robust foundation for querying AppSync-based project data with support for pagination, multi-source inputs, and secure cleanup of temporary artifacts. By refining credential management, tightening security controls around file handling, and tailoring the GraphQL query to your exact data needs, you can confidently run this pattern in production environments.

Call to action: Import this template into your n8n instance, connect it to a non-production AppSync endpoint, and adapt the query filters and fields to match your project model. Once validated, integrate it as a reusable component in your broader automation architecture.

Reverse Engineer Short-Form Videos with n8n & AI

Short-form videos on Instagram Reels and TikTok are full of subtle creative decisions: framing, pacing, camera motion, lighting, and visual style. This guide shows you how to use an n8n workflow template to automatically download a Reel or TikTok, convert it to a base64 payload, send it to Google Gemini for detailed forensic analysis, and receive a structured “Generative Manifest” in Slack that you can reuse for AI video generation.

What you will learn

By the end of this tutorial-style walkthrough, you will be able to:

• Explain why automating video reverse engineering is useful for content and AI workflows
• Understand each part of the n8n workflow and how the nodes connect
• Configure the Instagram and TikTok scraping branches using Apify
• Send an MP4 video to Google Gemini as base64 and retrieve a “Generative Manifest”
• Deliver the AI-generated manifest to Slack as a reusable prompt file
• Design and improve the analysis prompt for more accurate, production-ready outputs

Why automate reverse engineering of short-form videos?

Manually breaking down a short-form video is slow and inconsistent. You have to watch frame by frame, guess lens choices, estimate timing, and describe motion in words. This is difficult to repeat across many videos or share with a team.

By automating the process with n8n and AI, you can:

• Save time by letting a workflow handle downloading, converting, and analyzing videos
• Produce consistent, structured descriptions every time
• Generate highly detailed prompts that can be fed directly into generative video models
• Create a repeatable pipeline for reverse engineering and recreating short-form content

High-level overview of the workflow

Here is what the n8n workflow template does from start to finish:

• Collects a user-submitted Instagram Reel or TikTok URL from a form
• Detects which platform the URL belongs to and routes it to the correct scraper
• Uses Apify acts to extract the video asset and metadata
• Downloads the MP4 file and converts it to a Base64-encoded string
• Sends the encoded video plus a structured reverse engineering prompt to Google Gemini
• Receives a detailed “Generative Manifest” from Gemini
• Converts the manifest text into a file and posts it to Slack for review and reuse

Tools and services used in the template

• n8n – visual automation platform that orchestrates triggers, conditions, and HTTP requests
• Apify acts – scrapers for Instagram Reels and TikTok that return video URLs and metadata
• Google Gemini – generative language model used to analyze the video and output the Generative Manifest
• Slack – messaging platform used to deliver the resulting prompt file to your team

Prerequisites before you start

To run this workflow template successfully, you will need:

1. An n8n instance, either self-hosted or n8n cloud
2. An Apify API key with access to Instagram and TikTok scraping acts
3. A Google Cloud API key with access to Gemini, or equivalent generative model credentials
4. Slack OAuth app credentials with permission to post messages and upload files

How the n8n workflow is structured

The workflow is organized into three main stages:

1. Input and platform routing
2. Platform-specific processing (Instagram branch and TikTok branch)
3. Delivery of the Generative Manifest to Slack

Let us walk through each stage step by step.

Stage 1 – Input and routing

Nodes involved: form_trigger → set_base_prompt → switch_platform

1. Form input

The form_trigger node is where the workflow begins. It exposes a simple form with one required field:

• A single URL input where the user pastes either an Instagram Reel link or a TikTok link

Once the user submits the form, the URL is passed into the rest of the workflow.

2. Base analysis prompt

The set_base_prompt node prepares the core instructions that will be sent to Google Gemini later. It:

• Defines a detailed “Digital Twin Architect” persona that acts as a forensic analyst
• Instructs the model to be precise, non-interpretive, and deterministic
• Sets the structure for the Generative Manifest, such as sections for shots, camera, lighting, and physics

This base prompt is later combined with platform-specific metadata to give Gemini more context.

3. Platform detection and routing

The switch_platform node inspects the submitted URL and decides which branch of the workflow to run. It typically uses simple checks like:

• If the URL contains instagram.com then route to the Instagram Reel branch
• If the URL contains tiktok.com then route to the TikTok branch

From here, only the relevant branch is executed for that URL.

Stage 2 – Platform-specific branches

The workflow has two parallel branches, one for Instagram Reels and one for TikTok. Both follow the same logical pattern:

1. Scrape metadata and video URL
2. Build a final prompt that includes metadata
3. Download the MP4 video
4. Convert the video to base64
5. Send the video and prompt to Gemini
6. Extract and store the AI result

2.1 Instagram Reel branch

Nodes involved: scrape_ig_reel → build_final_ig_prompt → download_ig_reel → ig_to_base64 → analyze_ig_reel → set_ig_result

Step 1 – Scrape the Instagram Reel

The scrape_ig_reel node calls an Apify act dedicated to Instagram. This node:

• Uses the Reel URL to fetch post-level data
• Retrieves the direct videoUrl for the MP4 file
• Collects metadata such as caption, hashtags, and possibly a title

Step 2 – Build the final prompt for Instagram

The build_final_ig_prompt node merges two sources of information:

• The generic base prompt from set_base_prompt
• Instagram-specific metadata returned by the scraper (caption, tags, etc.)

The result is a tailored prompt that gives Gemini both the forensic instructions and context about the content, which helps it interpret timing and on-screen text more accurately.

Step 3 – Download the Reel video

The download_ig_reel node uses the scraped videoUrl to download the Reel as an MP4 file. The binary data is stored in n8n so it can be transformed in the next step.

Step 4 – Convert MP4 to base64

The ig_to_base64 node converts the MP4 binary into a Base64-encoded string and stores it in a JSON property. This step is important because:

• Google Gemini expects inline media data in base64 format
• The workflow needs to pass the video payload directly inside the API request

Step 5 – Analyze the Reel with Google Gemini

The analyze_ig_reel node sends a request to the Gemini API that includes:

• The full text prompt created in build_final_ig_prompt
• The base64-encoded video data with the correct MIME type, such as video/mp4

Gemini responds with a detailed Generative Manifest that describes the video shot by shot, including camera behavior, timing, and other requested details.

Step 6 – Store the Instagram analysis result

The set_ig_result node parses Gemini’s response and extracts the main textual result. Typically this is the model’s first candidate output. It then stores this text in a property named result, which will be used later when sending content to Slack.

2.2 TikTok branch

Nodes involved: scrape_tiktok → build_final_tiktok_prompt → download_tiktok → tiktok_to_base64 → analyze_tiktok → set_tiktok_result

The TikTok branch mirrors the Instagram branch, but uses TikTok-specific scrapers and field names.

Step 1 – Scrape the TikTok video

The scrape_tiktok node calls an Apify act designed for TikTok. It:

• Uses the TikTok URL to fetch video metadata
• Returns a direct video URL for the MP4 file
• Provides TikTok-specific fields like description, tags, or sound information (depending on the act configuration)

Step 2 – Build the final TikTok prompt

The build_final_tiktok_prompt node combines:

• The shared base prompt from set_base_prompt
• TikTok metadata from the scraper’s response

This gives Gemini a similar level of context as in the Instagram branch, but tailored to TikTok’s structure and content style.

Step 3 – Download the TikTok video

The download_tiktok node retrieves the MP4 file from the scraped video URL and stores the binary data in n8n.

Step 4 – Convert MP4 to base64

The tiktok_to_base64 node encodes the binary video data into a base64 string inside a JSON field, preparing it for the Gemini API request.

Step 5 – Analyze the TikTok video with Gemini

The analyze_tiktok node sends the TikTok-specific prompt and base64 video payload to Google Gemini, again specifying video/mp4 as the MIME type. Gemini returns a TikTok-focused Generative Manifest.

Step 6 – Store the TikTok analysis result

The set_tiktok_result node extracts the main text candidate from the Gemini response and stores it in a result property, aligning with the Instagram branch so that the downstream Slack delivery can handle either platform uniformly.

Stage 3 – Delivering the Generative Manifest to Slack

Nodes involved: Convert to File → upload_file → send_prompt_msg

1. Convert text result to a file

Once either branch has produced a result property, the Convert to File node turns this text into a downloadable file. For example, it might create a file named prompt.md or manifest.txt. This makes it easier for collaborators to store, edit, or import the prompt into other tools.

2. Upload the file to Slack

The upload_file node uses the Slack file upload API to send the generated prompt file to a chosen Slack channel. This requires that your Slack app has the correct OAuth scopes, such as files:write, and permission to post in that channel.

3. Post a message with a link to the manifest

The send_prompt_msg node posts a short Slack message that:

• Mentions that a new Generative Manifest is available
• Includes a link or reference to the uploaded file

This way, teammates can quickly open the file, review the analysis, and copy the prompt into their generative video tools.

Designing an effective Generative Manifest prompt

The quality of the Generative Manifest that Gemini returns is heavily influenced by how you design the base prompt in set_base_prompt. In this template, the persona “Digital Twin Architect” is used to enforce a forensic, deterministic style and avoid vague or interpretive descriptions.

Key sections you should include in your prompt design:

• Global aesthetic and camera emulation
  Describe the overall look and feel of the video, such as:
  • Camera sensor or film stock being emulated
  • White balance and color temperature
  • Grain level, contrast, and saturation
• Per-shot breakdowns
  Ask for a shot-by-shot analysis that includes:
  • Exact time offsets and durations
  • Framing and composition details
  • Camera movement curves and speed
  • Focus pulls and depth of field changes
  • On-screen micro-actions tied to precise timestamps
• Lighting blueprint and environment
  Request a detailed lighting plan that covers:
  • Light temperature and color
  • Key light size, distance, and angle
  • Practical light sources in the scene
  • Atmospherics like dust or particles and how they catch light
• Physics and simulation constraints
  For generative video tools that support physics, include:
  • Cloth behavior and how it reacts to motion or wind
  • Fluid dynamics, splashes, or smoke movement
  • Particle density and distribution
  • How these elements interact with light and objects

Tips to improve analysis accuracy

To get more reliable and detailed Generative Manifests, consider these best practices:

• Use high quality source videos
  Provide the highest bitrate version you can. Overly compressed MP4s make it harder for Gemini to detect subtle motion, grain, and fine texture.
• Include rich metadata in the prompt
  Feed extra context like the uploader handle, caption text, visible titles, and on-screen overlays into the prompt. This helps the model align visual events with meaning and timing.
• Adjust model settings for precision
  If your Gemini configuration allows it, lower the temperature and limit candidate diversity to favor precise, rule-based outputs instead of creative variations.
• Split long videos into segments
  For longer content, cut the video into shot segments before analysis. Running the workflow on shorter segments often yields more granular, accurate manifests.

Security, privacy, and legal considerations

Before you automate video analysis, keep these points in mind:

• Ensure you have legal rights to download and analyze
  

Automate User Sign‑Ups with n8n + Notion

This guide teaches you how to build a reliable sign‑up automation with n8n and Notion. You will learn how to accept webhook requests, find or create users in a Notion database, and automatically link each user to the current semester without losing previous semester relationships.

What you will learn

By the end of this tutorial, you will be able to:

• Set up an n8n webhook to receive sign‑up data from a form or external service.
• Normalize incoming data into predictable fields (name and email).
• Query a Notion Users database to find existing users and avoid duplicates.
• Create new Notion user records or update existing ones.
• Fetch the current semester from a separate Notion database.
• Safely merge semester relations so older semesters are kept and the current one is added.
• Secure and test the workflow for production use.

Why automate sign‑ups with n8n and Notion?

Notion is a flexible database that works well for storing user records, such as students, customers, or members. n8n is an open‑source automation platform that connects webhooks, APIs, and logic without requiring a full custom backend.

Combining n8n with Notion lets you:

• Accept sign‑ups through a webhook from any form or service.
• Prevent duplicate user records by checking Notion for an existing email first.
• Maintain relationships between users and semesters or cohorts.
• Protect your sign‑up endpoint using Basic Auth or other authentication methods.

How the n8n + Notion workflow works

At a high level, the workflow follows this logic:

1. Receive a sign‑up request via a webhook.
2. Extract and standardize the name and email fields.
3. Look up the user in the Notion Users database by email.
4. Branch:
   • If the user exists, fetch their full Notion page.
   • If the user does not exist, create a new Notion user page.
5. Query a separate Notion database to find the current semester.
6. Merge the current semester with any existing semesters for that user.
7. Update the user record so the Semesters relation includes the current semester without dropping older ones.

Example webhook payload

Your sign‑up form or external service should send a POST request to the n8n webhook. A minimal example payload looks like this:

{  "name": "John Doe",  "email": "john.doe@example.com"
}

Step‑by‑step: Building the workflow in n8n

1. Create the Sign Up Webhook node

The Sign Up (Webhook) node is the entry point for your workflow.

Recommended configuration:

• HTTP Method: POST
• Path: /sign-up (or another endpoint you prefer)
• Authentication: Basic Auth or another secure method

Protecting the webhook is important because this endpoint will directly trigger user creation or updates in your Notion database.

2. Normalize the input with a Set node

Next, use a Set node (often named Extract Name and Email) to map the incoming data into consistent fields. This makes later nodes simpler and less error‑prone.

Example expressions in the Set node:

Name = {{$json["body"]["name"]}}
Email = {{$json["body"]["email"]}}

After this node, you should have predictable Name and Email properties available in the workflow.

3. Query Notion to check if the user already exists

Use a Notion getAll node (for example, named Query for User) to search your Users database by email. This step prevents duplicate user records.

Key configuration points:

• Select your Users database.
• Set a filter where the Email property equals the incoming Email from the previous node.
• Optionally set returnAll to true if you want to handle multiple matches, although in most setups you expect zero or one match.

4. Branch with an If node: user exists or not

Add an If node (for example, named If user exists) to decide whether to create a new user or update an existing one.

A common pattern is to check whether the merged result from the Notion query contains an id field. For example:

Object.keys($json).includes("id")

Use this condition as follows:

• True branch (user exists): The workflow continues to a node like Query User that fetches the full Notion page for that user.
• False branch (user does not exist): The workflow goes to a Create User Notion node that creates a new page using Name and Email.

5. Get or create the Notion user page

In the True branch, the Query User node retrieves the complete Notion page for the existing user. In the False branch, the Create User node creates a fresh user page in the Users database.

From this point onward, both branches should provide you with a single user page and its pageId. You will use this ID later to update the Semesters relation.

6. Query the current semester in Notion

Now you need to find which semester is currently active. Add another Notion getAll node, often called Query Current Semester.

Configure it to:

• Target your Semester database.
• Filter by a boolean property such as Is Current? set to true.
• Sort by created_time in descending order so the newest matching semester appears first.

The result should give you the page ID for the current semester that you will attach to the user.

7. Merge existing and new semester IDs

To avoid overwriting existing semester relations, you need to combine the current semester with any semesters already linked to the user. This is often done using a small Function node after merging the outputs from the user and semester queries.

The goal is to build an allSemesterIDs array that:

• Always includes the current semester ID.
• Preserves previous semesters.
• Does not duplicate the current semester.

Example function code:

for (item of items) {  const currentSemesterID = item.json["currentSemesterID"]  let allSemesterIDs = [currentSemesterID];  if (item.json["Semesters"]?.length > 0) {  allSemesterIDs = allSemesterIDs.concat(  item.json["Semesters"].filter(semesterID => semesterID !== currentSemesterID)  );  }  item.json["allSemesterIDs"] = allSemesterIDs
}

return items;

This logic ensures that the current semester is included once and that any previously related semesters remain attached to the user.

8. Update the user’s Semesters relation in Notion

Finally, use a Notion update node, often named Update Semester for User, to write the merged semester information back to the user’s page.

Key points for configuration:

• Use the pageId from the Query User or Create User node.
• Set the Semesters relation property using the allSemesterIDs array produced by the Function node.
• Make sure the relations are formatted as Notion expects, typically an array of relation objects containing IDs or properly structured relation fields.

If you are not sure about the format, use the Notion node UI to create a sample relation manually and inspect how n8n structures the data.

Security and validation best practices

Before using this workflow in production, harden it with a few safeguards:

• Protect the webhook: Use Basic Auth or a secret token header. The example workflow uses HTTP Basic Auth credentials.
• Validate inputs: In a Set or Function node, check that required fields are present and that the email has a valid format.
• Handle repeated requests: Consider rate limiting or debouncing if your form or provider may resend the same payload multiple times.
• Log errors: Send error details to a monitoring service or a dedicated Notion log database so you can review and retry failed runs.

How to test and debug your workflow

Use these steps to safely test the workflow before connecting it to real users:

1. Run n8n in a safe or test environment and point it to a test copy of your Notion databases.
2. Send sample POST requests to the webhook, including Basic Auth headers, using the example JSON payload shown earlier.
3. Inspect each node’s output in n8n’s execution view to verify that:
   • Emails are extracted correctly.
   • Notion queries return the expected records.
   • The merged allSemesterIDs array contains the right IDs.
4. Check Notion directly:
   • New users should be created when no existing record is found.
   • Existing users should keep their old Semesters relations and receive the new current semester as well.

Common pitfalls and how to avoid them

• Incorrect Notion filters: Ensure the property key used in the filter exactly matches the Notion field, for example "Email|email" if that is how it appears in the schema.
• Relation formatting: Notion relations must be passed as arrays of properly structured objects. Use the Notion node UI to create a relation once, then copy that structure into your workflow.
• Duplicate records: If multiple pages share the same email, decide how to handle it: merge data, pick the first result, or notify an administrator.
• Time zone issues: When sorting by created_time to find the current semester, be aware of time zone differences that might affect which record appears as the most recent.

Scaling and improving the workflow

As your sign‑up volume grows, you can enhance this workflow in several ways:

• Add idempotency keys: Include a unique request ID and ignore repeated requests with the same ID to prevent duplicate processing.
• Introduce a queue: Use a queue system, such as Redis or a dedicated job queue, if you expect high traffic that might hit Notion API rate limits.
• Centralize logging and alerts: Send logs and errors to a central service so you can monitor failures and respond quickly.
• Version your workflow: Keep versions of the workflow so changes to Notion fields or database structures can be rolled out safely.

Quick recap

This n8n + Notion workflow lets you:

• Receive sign‑ups securely via a webhook.
• Check for existing users and avoid duplicate Notion records.
• Create or update user pages in a Notion Users database.
• Automatically associate each user with the current semester without losing past semester links.

The result is a low‑code, maintainable system for user onboarding and record management that can grow with your needs.

FAQ

Can I use a different field instead of email to identify users?

Yes. Email is common and convenient, but you can filter on any unique identifier in your Notion Users database, such as a student ID or username. Just update the Notion filter and the incoming payload accordingly.

What if there are multiple current semesters?

The recommended setup assumes only one semester has Is Current? set to true. If more than one matches, the sort by created_time will pick the newest. If you need different behavior, adjust the filter or add extra logic in n8n.

How do I know the relation format is correct?

Create or edit a relation manually using the Notion node UI, then look at the JSON generated in n8n’s execution view. Use that as a template for how to pass relation IDs in your update node.

Try the template

You can use the existing n8n template as a starting point. To get it running:

• Deploy the webhook node and configure authentication.
• Set your Notion credentials and database IDs for Users and Semesters.
• Send a sample payload to confirm everything works as expected.

If you want a copy of the template or help adapting it to your specific Notion schema, you can request a consultation or subscribe to receive more n8n + Notion automation tutorials.

Assign Values to Variables Using the n8n Set Node

If you spend any time building workflows in n8n, the Set node quickly becomes one of those tools you reach for almost without thinking. It is simple on the surface, but incredibly handy whenever you need to shape, clean, or prepare data as it moves through your automation.

In this guide, we will walk through what the Set node actually does, how to set number, string, and boolean values, how to use expressions for dynamic data, and a few tips to keep your workflows tidy and predictable. Think of it as your friendly cheat sheet for assigning values in n8n.

What Is the Set Node in n8n?

At its core, the Set node lets you control the fields that exist on each item that passes through your workflow. You can:

• Add new fields and variables
• Change or overwrite existing fields
• Remove fields you do not want to keep

That makes it perfect for everyday tasks such as:

• Creating fixed variables like API keys, flags, or counters
• Normalizing data into a consistent schema before it reaches other nodes
• Renaming, combining, or splitting fields to match what another service expects

If you have ever thought, “I just need to tweak this data a bit before sending it on,” the Set node is usually the right answer.

Why Use the Set Node Instead of a Function Node?

You might be wondering, “Couldn’t I just do this in a Function node?” You absolutely can, but the Set node has a few advantages for simple assignments:

• It is visual – you see exactly which fields you are setting without reading code.
• It is safer – you are less likely to break things by accident when all you are doing is assigning values.
• It is faster to configure – especially for basic number, string, or boolean fields.

When you get into complex transformations or heavy logic, a Function node becomes more useful. For simple data shaping and variable assignment, the Set node keeps things clean and easy to understand.

First Look: A Simple Set Node Example

Let us start with a tiny workflow so you can see the Set node in action. This example uses a Manual Trigger followed by a Set node that creates three fields: number, string, and boolean.

{  "nodes": [  {  "name": "On clicking 'execute'",  "type": "n8n-nodes-base.manualTrigger"  },  {  "name": "Set",  "type": "n8n-nodes-base.set",  "parameters": {  "values": {  "number": [  { "name": "number", "value": 20 }  ],  "string": [  { "name": "string", "value": "From n8n with love" }  ],  "boolean": [  { "name": "boolean", "value": true }  ]  }  }  }  ]
}

When you run this workflow, the Set node outputs an item with:

• number: 20
• string: “From n8n with love”
• boolean: true

That is all it does: it takes whatever comes in, adds these three fields, and passes everything along to the next node. Simple, but powerful once you start using it everywhere.

How to Configure the Set Node Step by Step

Let us quickly walk through setting this up in the n8n UI. You do not need any special data source to follow along, just your n8n instance.

1. Add a trigger to test with

For testing, the easiest option is the Manual Trigger node. Drop it on the canvas. This lets you click Execute and immediately see what your workflow outputs.

2. Connect a Set node

Next, drag a Set node onto the canvas and connect it to the Manual Trigger. Open the Set node and you will see a UI where you can define new fields and choose their types.

For each field you want to add, you can:

• Enter a field name
• Pick a type, such as number, string, or boolean
• Provide a value

To recreate the earlier example, you would add:

• number with value 20 (type: number)
• string with value From n8n with love (type: string)
• boolean with value true (type: boolean)

3. Run the workflow and inspect the output

Click Execute on the Manual Trigger, then open the Set node’s output. You should see the three fields you just created, plus any data that was already on the incoming item.

Once you are comfortable with static values, you are ready for the fun part: expressions.

Using Expressions in the Set Node

Static values are useful, but workflows really shine when your values change based on previous nodes or the current time. That is where expressions come in.

In the Set node, instead of typing a fixed value, you can click into the value field and switch to an expression. A few common patterns:

Reference data from previous nodes

To copy a value from the incoming item, you can use:

{{$json["previousField"]}}

This reads the field previousField from the current item’s JSON and assigns it to your new field.

Use built-in helpers like time functions

Need a timestamp? n8n gives you handy helpers like $now:

{{ $now.toISOString() }}

You can use this in the Set node to store when an item was processed, for example.

Expressions let you compute values dynamically, pull in data from earlier steps, or even do light transformations without writing a full Function node.

Common Set Node Options You Should Know

“Keep Only Set” for a clean payload

One important option you will often see in the Set node is Keep Only Set. When you enable it, the node removes every field that you did not explicitly define in this Set node.

Use this when you want to:

• Send a very specific payload to an API
• Make sure no extra or sensitive fields are passed downstream
• Clean up noisy data from previous nodes

Overwriting existing fields

If the incoming item already has a field with the same name, the Set node will overwrite it. This is extremely useful when you are normalizing data, but it can also cause confusion if you forget it is happening.

If you want to keep the original value, consider:

• Renaming the new field, for example normalizedPrice instead of price
• Copying the old field to something like priceOriginal before overwriting

Keeping data types consistent

Data types matter in n8n. You will save yourself a lot of debugging if you keep them consistent:

• Use numbers for anything you will calculate with.
• Use booleans for flags that you will check in IF or Switch nodes.
• Use strings when you are dealing with text or IDs.

For example, "20" is a string, while 20 is a number. They are not the same when you start doing math or comparisons, so it is worth getting them right at the Set node stage.

Practical Example: Using Set With Expressions

Let us look at a slightly more realistic scenario. Imagine you receive items with a price field as a string, such as "12.50", but you need a numeric field for calculations. You can convert it in the Set node with an expression:

{{ parseFloat($json["price"]) }}

In the Set node, you could define multiple fields at once, for example:

{  "priceNumber": {{ parseFloat($json["price"]) }},  "receivedAt": "{{ $now.toISOString() }}",  "isProcessed": false
}

Here is what is happening:

• priceNumber becomes a real number, ready for totals and calculations.
• receivedAt stores the current timestamp in ISO format.
• isProcessed is a boolean flag you can later flip to true or check in IF nodes.

This pattern comes up a lot when you are cleaning incoming data and preparing it for reports, invoices, or API calls.

Advanced Ways to Use the Set Node

1. Build clean API payloads

Before sending data to an external API, it is a good idea to build a clean, predictable payload. A Set node is perfect for this.

You can use it to:

• Rename fields to match the API’s schema
• Drop fields you do not want to send by enabling “Keep Only Set”
• Ensure all required fields are present and correctly typed

This reduces surprises, like accidentally sending internal fields or malformed values to external services.

2. Rename and combine fields

Need to adapt data from one service to another? The Set node is great for mapping fields. For example, if your previous node returns first_name and last_name, but the next service expects a single fullName field, you can create it with an expression:

{{ $json["first_name"] + " " + $json["last_name"] }}

You can keep or remove the original fields depending on your needs. This kind of small transformation keeps your workflows flexible without resorting to heavy custom code.

3. Create control flags for routing

Another common pattern is using the Set node to define boolean flags, like:

• isHighPriority
• shouldNotify
• needsReview

Later on, your IF or Switch nodes can read these flags and route items differently. It keeps your logic readable because you are essentially labeling items with clear, human friendly tags.

Troubleshooting Your Set Node

Things not working quite as expected? Here are a few quick checks.

• Fields not showing up? Make sure the Set node is actually connected to the right input, and that you clicked Execute on the workflow or node.
• Confused about what the node outputs? Open the node’s output preview or use the Debug panel to see exactly what fields are present.
• Expression errors? Double check your syntax and confirm that the fields you reference, like $json["price"], actually exist on the incoming item.
• Type issues? Remember that numbers in quotes are strings. Use helpers like parseFloat or parseInt to convert them to real numbers when needed.

Best Practices for Using the Set Node

1. Use clear, descriptive field names. Future you (and your teammates) will thank you when reading the workflow later.
2. Change only what you need. Avoid renaming or overwriting fields unless you have a specific reason to. Less surprise means easier debugging.
3. Give each Set node a single main purpose. For example, one node to normalize input, another to build an API payload, another to set flags. It keeps your workflow modular and easier to follow.
4. Document tricky expressions. If you use a non-obvious expression, add a note on the node so others understand why it is there.

When the Set Node Is Not Enough

There are times when the Set node is not the best tool. If you need to:

• Perform complex calculations or multi step logic
• Iterate over arrays and create multiple new items
• Do heavy transformations on nested data structures

then a Function node or techniques like SplitInBatches or Item Lists might be a better fit.

For simple assignments though, the Set node is ideal. It is fast to configure, easy to read, and low risk compared to writing custom code.

Wrapping Up

The Set node is one of those small but essential building blocks in n8n. It helps you:

• Create and manage workflow variables
• Prepare clean payloads for APIs and other services
• Keep your data types and schemas consistent

Start with basic static values, like numbers, strings, and booleans, then gradually bring in expressions to make your workflows more dynamic and powerful.

Ready to Try It?

Open your n8n instance, drop in a Manual Trigger and a Set node, and recreate the simple example from earlier. Then experiment a bit:

• Change the values and types
• Reference fields from previous nodes
• Add timestamps and flags with expressions

The more comfortable you get with the Set node, the smoother the rest of your workflow building will feel.

If you want more n8n tips and automation ideas, subscribe to our newsletter for advanced recipes or grab a sample workflow you can import and run right away.