DEV Community: Pirate Prentice

n8n GitHub Node: Automate Issues, Pull Requests, and Releases in Your Workflows [Free Workflow JSON]

Pirate Prentice — Thu, 16 Jul 2026 07:22:17 +0000

If your team lives in GitHub, you're already doing manual work that n8n can eliminate: pasting issue links into Slack, copying PR details into project trackers, sending release notes to customers, and keeping spreadsheets in sync with repo activity. The n8n GitHub node connects your repositories to every other tool in your stack—without webhooks you have to maintain, without Zapier's per-task pricing, and without writing GitHub API boilerplate.

This guide covers every GitHub node operation, the six most common gotchas, three production-ready workflow patterns, and a free downloadable JSON you can import directly into n8n.

What the n8n GitHub Node Can Do

The GitHub node in n8n wraps the GitHub REST API. Here's what you can read, create, and update:

Issues

Create Issue: open a new issue with title, body, labels, assignees, milestone
Edit Issue: update state (open/closed), labels, assignees, title, body
Get Issue / Get All Issues: fetch by number or list with filters (state, label, assignee, since)
Lock / Unlock Issue: restrict or restore comments
Create Comment: post a comment on an existing issue

Pull Requests

Create PR: open a pull request from branch to base
Get PR / Get All PRs: list open/closed/merged PRs with filters
Get PR Files: list changed files and their diffs
Get PR Reviews: fetch review status and comments
Update PR: change title, body, state, or base branch

Repositories

Get Repository: fetch repo metadata (stars, forks, topics, default branch)
List Repositories: list repos for a user or org
Get File: read file content from any branch/commit (base64 decoded)
Create / Edit File: commit a file change directly (useful for config updates, README patches)
Delete File: remove a file via commit

Releases

Create Release: publish a new release with tag, name, body, draft/prerelease flags
Get Release / Get All Releases: list releases with assets
Update Release: edit body, name, draft state
Delete Release

Triggers (GitHub Trigger node)

Fires on: push, pull_request, issues, issue_comment, release, create, delete, workflow_run, and more
Configure via n8n's built-in webhook URL—no manual GitHub webhook setup needed

Credentials Setup

Generate a Personal Access Token (PAT) at GitHub → Settings → Developer settings → Personal access tokens (classic or fine-grained)
Scopes needed: repo (full control of private repos) or public_repo for public-only access. For org repos, read:org may also be needed.
In n8n: Credentials → New → GitHub → paste the PAT
Fine-grained tokens (2024+): scope to specific repos and permissions for least-privilege access

Six Common Gotchas

1. Base64-encoded file content
The "Get File" operation returns content as base64. Add a Code node to decode: Buffer.from($input.item.json.content, 'base64').toString('utf-8'). Forgetting this gives you garbled output in downstream nodes.

2. Pagination on "Get All" operations
n8n's GitHub node handles pagination automatically when "Return All" is enabled—but large repos (1,000+ issues) can be slow and hit rate limits. Set filters (state, label, since date) to narrow the result set before enabling Return All.

3. Rate limits: 5,000 requests/hour per authenticated user
Authenticated requests get 5,000/hr; unauthenticated get 60/hr. Bulk operations over large repos can exhaust this. Add error handling and exponential backoff in a Code node, or schedule heavy pulls during off-hours.

4. GitHub Trigger requires a public webhook endpoint
The GitHub Trigger node needs a publicly reachable webhook URL. On a local n8n instance, you'll need an ngrok tunnel or cloud n8n. The trigger auto-registers the webhook in your repo settings.

5. SHA required for file updates
The "Edit File" operation requires the current file's SHA (returned by "Get File"). If you skip this step and pass a stale or missing SHA, the operation fails with a 409 conflict.

6. Organization repos vs. personal repos
Some operations require specifying the org name as the "Owner" (not your username). When accessing org repos, confirm the PAT has read:org scope and that the org allows PATs.

Three Production-Ready Workflow Patterns

Pattern 1: GitHub Issue → Slack + Linear Triage Bot

Problem: New issues pile up untracked. Team doesn't know which issues are high-priority until someone manually reviews them.

Workflow:

GitHub Trigger: fires on issues event (action: opened)
AI Node (OpenAI/Anthropic): classify the issue as bug/feature/question, assign severity 1-3 based on title + body
IF node: if severity = 1 (critical bug)
- Slack node: post to #incidents with issue link, title, and classification
- Linear node (HTTP Request): create a Linear issue in the "Critical" team with GitHub link
IF node else: post to #triage Slack channel for async review

Why it works: Zero manual triage. Critical bugs get immediate team visibility. Non-critical issues queue in Slack for async review. No context switching between GitHub and project tools.

Pattern 2: Release Notes Auto-Publisher

Problem: Every release requires someone to manually copy the GitHub release body into Slack, email subscribers, and update a changelog doc.

Workflow:

GitHub Trigger: fires on release event (action: published)
Filter node: skip prereleases (check $input.item.json.body.prerelease === true)
Parallel branches:
- Branch A: Slack node → post formatted release summary to #announcements
- Branch B: Brevo/Resend node → send release email to opted-in changelog subscribers
- Branch C: Google Sheets node → append version, date, and summary to a changelog Sheet
GitHub node: Create Comment on all issues/PRs that reference this release milestone (via search)

Why it works: Releases trigger a full distribution chain with no manual steps. Every stakeholder is updated through their preferred channel within seconds of the tag being published.

Pattern 3: PR Quality Gate Notifier

Problem: PRs sit unreviewed for days. Large PRs (500+ lines) get rubber-stamped. No visibility into review queue health.

Workflow:

Schedule Trigger: runs every day at 9 AM
GitHub node: Get All PRs (state: open) for your repository
Code node: calculate age in hours, count changed files from PR metadata
Item Lists node: aggregate and sort by age descending
IF node: filter PRs older than 48 hours OR with >10 files changed (high review burden)
Slack node: post a daily digest to #engineering — "PRs needing attention" list with author, age, file count, link
IF node (>7 days old): send a direct Slack DM to the PR author asking for a status update or close intent

Why it works: Surfaces stale reviews and oversized PRs before they become merge bottlenecks. The daily digest creates a lightweight standup artifact without any manual compilation.

Free Workflow JSON

Import this into n8n (Settings → Import Workflow) to get the PR Quality Gate Notifier pre-wired. Update the repository owner/name, Slack channel, and your alert thresholds.

{
  "name": "GitHub PR Quality Gate Notifier",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [{"field": "cronExpression", "expression": "0 9 * * 1-5"}]
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "resource": "pullRequest",
        "operation": "getAll",
        "owner": "YOUR_ORG_OR_USER",
        "repository": "YOUR_REPO",
        "returnAll": true,
        "filters": {"state": "open"}
      },
      "name": "Get Open PRs",
      "type": "n8n-nodes-base.github",
      "typeVersion": 1,
      "position": [450, 300]
    },
    {
      "parameters": {
        "jsCode": "const now = Date.now();\nreturn $input.all().map(item => {\n  const pr = item.json;\n  const ageHours = (now - new Date(pr.created_at).getTime()) / 3600000;\n  return {\n    json: {\n      number: pr.number,\n      title: pr.title,\n      author: pr.user.login,\n      url: pr.html_url,\n      ageHours: Math.round(ageHours),\n      changedFiles: pr.changed_files || 0,\n      stale: ageHours > 48,\n      oversized: (pr.changed_files || 0) > 10\n    }\n  };\n});"
      },
      "name": "Enrich PRs",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [650, 300]
    },
    {
      "parameters": {
        "conditions": {
          "boolean": [{"value1": "={{$json.stale || $json.oversized}}", "value2": true}]
        }
      },
      "name": "Needs Attention?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [850, 300]
    },
    {
      "parameters": {
        "channel": "#engineering",
        "text": "=:github: *PR needs attention:* <{{$json.url}}|#{{$json.number}} {{$json.title}}>\nAuthor: @{{$json.author}} | Age: {{$json.ageHours}}h | Files: {{$json.changedFiles}}"
      },
      "name": "Slack Alert",
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1050, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": {"main": [[{"node": "Get Open PRs", "type": "main", "index": 0}]]},
    "Get Open PRs": {"main": [[{"node": "Enrich PRs", "type": "main", "index": 0}]]},
    "Enrich PRs": {"main": [[{"node": "Needs Attention?", "type": "main", "index": 0}]]},
    "Needs Attention?": {"main": [[{"node": "Slack Alert", "type": "main", "index": 0}], []]}
  }
}

GitHub Node vs. HTTP Request Node

	GitHub node	HTTP Request node
Auth setup	PAT via n8n credential	Manual header
Coverage	Issues, PRs, releases, files	Full GitHub API (GraphQL too)
Pagination	Auto (Return All)	Manual cursor handling
Ease of use	High	Lower

Use the GitHub node for the operations it covers. Drop to HTTP Request for GraphQL queries, Actions API, or endpoints not yet in the node.

Putting It All Together

The GitHub node turns your repository into a live data source for every other tool in your stack. Issues become Linear tickets. Releases become Slack announcements and changelog emails. PRs become engineering digest entries. None of this requires a custom integration service—just an n8n workflow and a PAT.

Want this built for your repo but don't have time to wire it up? The Done-For-You n8n Workflow Build service ($99) delivers a production-ready GitHub automation tailored to your team's workflow within 3 business days.

Or grab the n8n Workflow Automation Pack ($29) for 10+ pre-built workflow templates including GitHub integrations.

More n8n guides: pirateprentice on dev.to

n8n Shopify Node: Automate Orders, Customers, and Inventory in Your Workflows [Free Workflow JSON]

Pirate Prentice — Wed, 15 Jul 2026 07:21:41 +0000

n8n Shopify Node: Automate Orders, Customers, and Inventory in Your Workflows [Free Workflow JSON]

If you're running a Shopify store, you're already drowning in repetitive tasks: exporting orders to spreadsheets, tagging customers by purchase history, emailing suppliers when stock runs low, and reconciling payments in your accounting tool. The n8n Shopify node connects your store to every other tool in your stack—without middleware, without Zapier's per-task pricing, and without writing custom API code.

This guide covers every Shopify node operation, the six most common gotchas, three production-ready workflow patterns, and a free downloadable JSON you can import directly into n8n.

What the n8n Shopify Node Can Do

The Shopify node in n8n covers the core Shopify Admin REST API resources. Here's what you can read, create, and update:

Orders

Get Order: fetch a single order by ID
Get All Orders: list orders with filters (status, date range, fulfillment status, financial status)
Create Order: programmatically create an order (useful for phone/offline orders)
Update Order: change tags, notes, or metafields on existing orders
Delete Order: remove a draft order

Customers

Get Customer / Get All Customers: retrieve customer records with purchase history
Create Customer: add new customers to your Shopify CRM
Update Customer: add tags, notes, addresses, or metafields
Delete Customer

Products

Get Product / Get All Products: list products with variant details, inventory levels, images
Create Product / Update Product / Delete Product

Triggers (Shopify Trigger node)

Order Created / Updated / Paid / Fulfilled / Cancelled / Partially Fulfilled
Customer Created / Updated
Product Created / Updated / Deleted
Checkout Created / Updated

Prerequisites

A Shopify store (any plan — even development stores work for testing)
A Custom App with the scopes your workflow needs
The Admin API access token from that app

Creating the credential in n8n

In Shopify Admin: Settings → Apps and sales channels → Develop apps → Create an app
Configure API scopes:
- Orders: read_orders, write_orders
- Customers: read_customers, write_customers
- Products: read_products, write_products
- Inventory: read_inventory, write_inventory
Install the app → copy the Admin API access token (shown only once)
In n8n: Credentials → New → Shopify API
- Shop subdomain: your-store (not your-store.myshopify.com)
- Access token: paste the token

Scope tip: Request only the scopes your workflow actually needs. Shopify logs scope usage — over-permissioned apps get flagged in security reviews.

The Six Gotchas That Will Bite You

1. The API rate limit is 40 requests/second — not per minute

Shopify's REST API uses a leaky-bucket rate limiter: 40 requests/second per store, replenishing at 2/second. For bulk operations (Get All Orders, syncing large product catalogs), n8n will hit this fast. Add a Wait node (500ms–1000ms delay) between batches, or use Split In Batches with a 10-item chunk and a pause. Hitting the limit returns 429 Too Many Requests and n8n will retry — but repeated retries can cascade into longer delays.

2. "Get All" has a default limit of 250 records — pagination is manual

The Shopify node's Get All operation fetches up to 250 records per call and doesn't auto-paginate. For stores with thousands of orders or customers, you need to implement cursor-based pagination manually using page_info from the response headers or switch to the Shopify GraphQL Admin API (via the HTTP Request node) which supports proper pagination. For most small-to-mid stores, 250 is enough for recent records.

3. Order financial_status vs fulfillment_status — they're independent

financial_status (pending, paid, refunded, partially_refunded) and fulfillment_status (fulfilled, partial, unfulfilled) are separate fields. A common mistake: filtering for status=any to get "all paid unfulfilled orders" — this requires filtering on both fields. Use Get All Orders with financial_status=paid and then a Filter node to check fulfillment_status != 'fulfilled'.

4. Webhooks need a public URL — use ngrok or a cloud n8n instance for development

The Shopify Trigger node registers a webhook with Shopify, which requires a publicly reachable URL. localhost:5678 won't work — Shopify can't reach it. Options:

n8n Cloud: URL is already public
Self-hosted on a VPS: public IP + the n8n webhook path works
Local dev: use ngrok (ngrok http 5678) — but the tunnel URL changes on restart, which re-registers the webhook

5. Webhook deduplication is your responsibility

Shopify guarantees at-least-once delivery, not exactly-once. During high-traffic events (flash sales, Black Friday), the same order.paid webhook can fire twice. Build deduplication into your workflow: use a Redis Set node or a Google Sheet to check order_id before processing. Without this, you'll send duplicate fulfillment emails, double-count revenue in sheets, or create duplicate CRM records.

6. Customer email is not always present

Guest checkouts in Shopify can produce orders where customer.email is null (the email lives at order.email instead). If your workflow sends confirmation or fulfillment emails, always fall back to {{ $json.order.email || $json.customer.email }} — never assume customer.email is populated.

Pattern 1: Order → Google Sheets Revenue Sync

Use case: Append every paid Shopify order to a Google Sheet for daily revenue tracking without exporting CSVs.

Trigger: Shopify Trigger node → Event: order/paid

Workflow:

Shopify Trigger (order/paid)
  → Set node: extract order_id, created_at, total_price, customer.email, line_items count, financial_status
  → Google Sheets (Append Row): sheet "Orders Log", columns: Date | Order ID | Customer Email | Total | Items | Status

Why it works: The order/paid webhook fires the instant payment is confirmed — not when the order is created (which may be unpaid). This avoids syncing abandoned checkouts or pending orders.

Dedup guard: Add a Google Sheets lookup (Get Row) before the append to check if order_id already exists in column B. If it does, stop execution. This handles Shopify's at-least-once delivery.

Free JSON: [included at end of article]

Pattern 2: Low-Stock Alert → Slack + Supplier Email

Use case: When a product variant drops below a stock threshold, alert the team on Slack and email the supplier automatically.

Trigger: Schedule Trigger → every 6 hours (or Shopify Trigger → product/updated if you want real-time)

Workflow:

Schedule Trigger (every 6h)
  → Shopify (Get All Products): limit=250
  → Split Out (operation: Split Out, field: variants)
  → Filter: inventory_quantity < 10 AND inventory_management == "shopify"
  → IF: no items pass filter → stop
  → Set node: build alert message with title, SKU, quantity, product URL
  → Slack (Send Message): channel #ops, message "⚠️ Low stock: {title} SKU {sku} — {qty} remaining"
  → Gmail (Send Email): to supplier@example.com, subject "Reorder needed: {title}", body with qty + Shopify admin link

Threshold config tip: Store the threshold (10) in a Set node at the top so you can change it without editing the Filter. Or use a Google Sheet as a config store — one row per SKU with its reorder point.

Pattern 3: New Order → CRM Contact Sync + Tag Enrichment

Use case: When a customer places their first order, create or update their record in HubSpot (or Airtable), add a "buyer" tag in Shopify, and trigger a post-purchase email sequence in Brevo.

Trigger: Shopify Trigger → order/paid

Workflow:

Shopify Trigger (order/paid)
  → IF: customer.orders_count == 1  (first-time buyer)
    YES →
      → HubSpot (Create/Update Contact): email, first/last name, "buyer" lifecycle stage
      → Shopify (Update Customer): add tag "buyer-first-order"
      → Brevo (Add Contact to List): list "post-purchase-sequence-new"
    NO → (repeat buyer path)
      → HubSpot (Update Contact): increment purchase_count property
      → IF: orders_count == 3
        YES → Shopify (Update Customer): add tag "loyal-customer"
        YES → Brevo (Add to List): "vip-sequence"

Why tag in Shopify too: Tags in Shopify make it easy to segment customers for future discount campaigns directly inside Shopify without needing to query your CRM.

Shopify Node vs HTTP Request Node (GraphQL)

Capability	Shopify Node	HTTP Request (GraphQL)
Setup complexity	Low — credential + select operation	Medium — GraphQL query syntax
Pagination	Manual (250/page limit)	Cursor-based (proper pagination)
Bulk exports (10K+ records)	Impractical	✅ via Bulk Operations API
Metafields	Limited	✅ Full access
Custom storefronts	❌	✅ Storefront API
Best for	Triggers + small CRUD ops	Large catalog syncs, complex queries

For most automation workflows (order events, customer tagging, stock checks), the native Shopify node is sufficient. Switch to GraphQL via HTTP Request only when you need bulk exports or metafield depth.

Free Workflow JSON

Import this directly into n8n (Settings → Import from clipboard):

{
  "name": "Shopify Order Revenue Sync + Low Stock Alert",
  "nodes": [
    {
      "parameters": {
        "event": "order/paid"
      },
      "name": "Shopify Trigger",
      "type": "n8n-nodes-base.shopifyTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            { "name": "order_id", "value": "={{ $json.id }}", "type": "string" },
            { "name": "created_at", "value": "={{ $json.created_at }}", "type": "string" },
            { "name": "total_price", "value": "={{ $json.total_price }}", "type": "string" },
            { "name": "customer_email", "value": "={{ $json.email }}", "type": "string" },
            { "name": "item_count", "value": "={{ $json.line_items.length }}", "type": "number" },
            { "name": "financial_status", "value": "={{ $json.financial_status }}", "type": "string" }
          ]
        }
      },
      "name": "Extract Fields",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [450, 300]
    },
    {
      "parameters": {
        "operation": "append",
        "documentId": { "__rl": true, "mode": "list", "value": "YOUR_SHEET_ID" },
        "sheetName": { "__rl": true, "mode": "list", "value": "Orders Log" },
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "Date": "={{ $json.created_at }}",
            "Order ID": "={{ $json.order_id }}",
            "Customer Email": "={{ $json.customer_email }}",
            "Total": "={{ $json.total_price }}",
            "Items": "={{ $json.item_count }}",
            "Status": "={{ $json.financial_status }}"
          }
        }
      },
      "name": "Log to Google Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.5,
      "position": [650, 300]
    }
  ],
  "connections": {
    "Shopify Trigger": { "main": [[{ "node": "Extract Fields", "type": "main", "index": 0 }]] },
    "Extract Fields": { "main": [[{ "node": "Log to Google Sheets", "type": "main", "index": 0 }]] }
  }
}

Replace YOUR_SHEET_ID with your Google Sheets document ID. Add a Google Sheets credential and a Shopify API credential before running.

Where to Go From Here

The Shopify node handles the most common e-commerce automations well. For production stores, consider these additions:

Inventory webhooks (inventory_levels/update) for real-time stock alerts instead of polling
Fulfillment automation: when an order is marked paid, trigger a fulfillment request to your 3PL via HTTP Request
Abandoned checkout recovery: use the checkouts/create trigger to start a Brevo sequence for carts left behind
Metafield sync: use the HTTP Request node (GraphQL) to read/write product metafields for custom attribute management

Get the Pre-Built n8n Workflow Pack

The free JSON above gives you the basics. If you want a complete Shopify automation bundle — order sync, customer tagging, low-stock alerts, and post-purchase sequences — all pre-wired and documented:

👉 n8n Workflow Starter Pack ($29) — pirateprentice.gumroad.com/l/sxcoe

Or if you'd rather have it built specifically for your store:

👉 Done-For-You n8n Workflow Build ($99) — buy.stripe.com/4gMdRaetT3Yv3yxbOs2go03

Send your store setup and what you want automated — I'll deliver a working n8n workflow within 48 hours.

n8n HubSpot Node: Sync Contacts, Deals, and Companies in Your Workflows (Free Workflow JSON)

Pirate Prentice — Tue, 14 Jul 2026 07:22:40 +0000

n8n HubSpot Node: Sync Contacts, Deals, and Companies in Your Workflows (Free Workflow JSON)

If you're managing a CRM in HubSpot and wish your automation workflows could reach in and pull, push, or update records without manual exports — the n8n HubSpot node is your answer.

This guide covers every operation you'll actually use, six gotchas that bite people, three real-world workflow patterns, and a free downloadable JSON so you can start in minutes.

What the HubSpot Node Does

The HubSpot node connects n8n to the HubSpot CRM API. You can:

Read, create, update, and delete contacts, companies, deals, and tickets
Search any CRM object with filters
Manage associations between objects (e.g., link a contact to a deal)
Upsert records — create if not found, update if found

Authentication is via a HubSpot Private App token (OAuth2 is also supported for multi-account setups).

Operations Reference

Contact Operations

Operation	What it does
Create	Add a new contact
Get	Fetch by ID
Get Many	List contacts with optional filters
Update	Update any property
Delete	Archive contact
Search	Filter by email, name, property value
Upsert	Create or update by email

Company Operations

Create, Get, Get Many, Update, Delete, Search

Deal Operations

Create, Get, Get Many, Update, Delete, Search
Set deal stage, associate with contacts/companies

Ticket Operations

Create, Get, Get Many, Update, Delete, Search

Association Operations

Create Association (link contact ↔ deal, company ↔ deal, etc.)
Get Associations
Delete Association

Authentication: Private App Token

In HubSpot → Settings → Integrations → Private Apps
Create a new app, select the scopes you need (contacts read/write, deals read/write, etc.)
Copy the token → paste into n8n as a HubSpot credential (Bearer Token type)

Scope tip: Request only the scopes your workflow needs. Least-privilege reduces blast radius if the token leaks.

Six Gotchas

1. Property names are internal names, not labels.
HubSpot displays "First Name" in the UI but the API property name is firstname. Use HubSpot's property settings page to look up internal names before building your workflow.

2. Search returns max 100 results per page.
The Search operation supports pagination via after cursor. For large lists, loop with a Code node until paging.next.after is null.

3. Upsert deduplicates by email only.
The built-in Upsert uses email as the unique key. If you need to deduplicate by phone or custom ID, use Search → IF → Create/Update manually.

4. Associations require separate requests.
Creating a deal doesn't automatically associate it with a contact. You must use the Association operation as a follow-up step — plan for two nodes per new deal creation.

5. Rate limits are per-second AND per-day.
HubSpot's API enforces 100 requests/10 seconds for Private Apps and 250K daily. For bulk syncs, add a Wait node (1s) between batches to avoid 429 errors.

6. Deleted records are archived, not permanently gone.
HubSpot's "Delete" archives records. They can be restored. If you're building a GDPR deletion flow, verify the record is permanently deleted via HubSpot's UI or a separate API call — n8n's Delete maps to the archive endpoint.

Workflow Pattern 1: Typeform Lead → HubSpot Contact + Deal

Trigger: Typeform Webhook (new form submission)
Steps:

Typeform Trigger node → extract name, email, company, budget
HubSpot node → Upsert Contact (email dedup)
HubSpot node → Create Deal (associate with contact ID from step 2)
HubSpot node → Create Association (contact ↔ deal)
Gmail/Resend → send confirmation email to lead

Why it matters: Every inbound lead lands in HubSpot automatically, with a deal created and associated in the same workflow — no manual CRM entry.

Workflow Pattern 2: HubSpot Deal Stage Change → Slack Alert + Google Sheet Log

Trigger: Schedule Trigger (every 15 min) or HubSpot webhook (requires HubSpot subscription webhook setup)
Steps:

HubSpot node → Search Deals where dealstage changed in last 15 minutes (use lastmodifieddate filter)
IF node → filter for deals moving to "Closed Won"
Slack node → post to #sales channel ("🎉 Deal closed: {deal name} — ${amount}")
Google Sheets node → append row to revenue tracker

Why it matters: Sales team gets instant Slack notifications on closed deals without HubSpot notifications being buried in email.

Workflow Pattern 3: Stripe Payment → HubSpot Contact Update + Note

Trigger: Stripe Webhook (charge.succeeded)
Steps:

Stripe Webhook Trigger → extract customer email, amount, invoice ID
HubSpot node → Search Contact by email
HubSpot node → Update Contact (set custom property last_payment_amount, last_payment_date)
HubSpot node → Create Engagement (Note) on contact: "Stripe payment received: ${amount} on {date}, invoice {id}"
IF node → if amount > $500, set contact property high_value_customer = true

Why it matters: Your CRM stays in sync with real payment data — support reps can see payment history directly in HubSpot without switching to Stripe.

Free Workflow JSON

Download the pre-built workflow for Pattern 1 (Typeform → HubSpot Contact + Deal):

👉 Get the free n8n HubSpot workflow JSON

Import it: n8n → top-right menu → Import from URL or paste JSON → connect your HubSpot credentials → activate.

HubSpot Node vs. HTTP Request Node

	HubSpot Node	HTTP Request to HubSpot API
Auth setup	Credential picker	Manual Bearer header
Available ops	Standard CRM ops	Full API including v3 custom objects
Pagination	Manual	Manual
Best for	Standard contact/deal/company workflows	Custom objects, bulk imports, advanced filters

Use the HubSpot node for 90% of cases. Use HTTP Request when you need HubSpot's v3 custom objects API or undocumented endpoints.

Key Takeaways

HubSpot node covers contacts, companies, deals, tickets, and associations
Authenticate with a Private App token scoped to exactly what you need
Property names are internal names — check HubSpot's property settings before building
Upsert by email is the cleanest dedup for inbound leads
Always create associations as a separate step after creating related objects
Rate limit: 100 req/10s — add Wait nodes in bulk workflows

n8n Notion Node: Sync Databases, Manage Pages, and Build Automated Workflows (Free Workflow JSON)

Pirate Prentice — Tue, 14 Jul 2026 03:22:38 +0000

Notion has become the default workspace for thousands of teams — but its real power unlocks when you connect it to the rest of your stack. The n8n Notion node lets you read and write Notion databases, create and update pages, manage blocks, and trigger workflows from Notion events. This guide covers the operations you'll use most, the gotchas that trip up new users, and three production patterns that actually ship.

Prerequisites

n8n (self-hosted or cloud)
A Notion account with at least one database
A Notion integration (internal or public) with the right capabilities

Setting up the Notion integration:

Go to notion.so/my-integrations → New integration
Give it a name, select your workspace, set capabilities: Read content, Update content, Insert content
Copy the Internal Integration Secret
In your Notion database/page: ⋯ menu → Add connections → your integration name (Notion requires explicit page-level connection grants)

In n8n: Credentials → New → Notion API → paste your Internal Integration Secret.

Operations at a Glance

Operation	What It Does
Database: Get	Fetch database metadata (schema, properties)
Database: Get Many	List databases the integration has access to
Database: Query	Filter and sort records in a database
Page: Create	Add a new page/row to a database
Page: Get	Fetch a page by its ID
Page: Update	Update page properties
Page: Archive	Archive (soft-delete) a page
Block: Get Many	Read the content blocks of a page
Block: Append	Add new blocks to a page

Key Configuration Concepts

Finding Your Database ID

Your Notion database URL looks like:
https://www.notion.so/myworkspace/abc123def456...?v=...

The database ID is the alphanumeric string between the last / and the ?v=. In n8n, you can paste the full URL — the node parses it automatically.

Property Types Matter

Notion properties have types (title, rich_text, number, select, multi_select, date, checkbox, url, email, phone_number, relation, formula, rollup). The n8n Notion node exposes these as typed fields. A common error: trying to set a formula or rollup field — those are computed by Notion, not writable via API.

Filtering in Database: Query

Filters use Notion's compound filter syntax. In n8n's UI, you build these with the visual filter builder. For complex compound filters, use the JSON input mode:

{
  "and": [
    { "property": "Status", "select": { "equals": "Active" } },
    { "property": "MRR", "number": { "greater_than": 100 } }
  ]
}

3 Production Workflow Patterns

Pattern 1: CRM-to-Notion Database Sync

Use case: New leads come in from a Typeform or webhook. You want them in a Notion CRM database — deduplicated, enriched, and linked to the right company page.

Workflow:

Webhook Trigger — receives lead data (name, email, company, source).
Notion – Database: Query — filter: { "property": "Email", "email": { "equals": "{{ $json.email }}" } }. Returns existing record if the lead exists.
IF node — {{ $json.results.length > 0 }} → true (existing) or false (new).
- False branch (new lead): Notion – Page: Create — database ID: your CRM DB, properties: name (title), email, company, source, Status (select: "New"), Created (date: today).
- True branch (existing lead): Notion – Page: Update — page ID from query results, update Last Seen date and append to Notes.
Merge node — rejoin and send a Slack notification either way.

Key config on Page: Create:

Properties → Title → set to lead name
Use the "Additional Fields" section for non-title properties
Date fields require ISO 8601 format: {{ $now.toISO() }}

Pattern 2: Automated Weekly KPI Report to Notion

Use case: Every Monday morning, pull KPI data from Stripe (revenue, new customers, refunds) and write it to a Notion database as a new weekly report page — so the team has a running log of weekly metrics in Notion without manual copy-paste.

Workflow:

Schedule Trigger — every Monday at 8:00 AM.
HTTP Request node — Stripe API: GET /v1/charges?created[gte]={{ $now.startOf('week').subtract(1, 'week').toUnixInteger() }}&created[lte]={{ $now.startOf('week').toUnixInteger() }} to get last week's charges.
Code node — aggregate: sum amounts, count customers, sum refunds, compute net revenue.
Notion – Page: Create — in your KPI Reports database:
- Title: Week of {{ $now.startOf('week').subtract(1, 'week').toFormat('MMM d') }}
- MRR (number): net revenue
- New Customers (number): customer count
- Refunds (number): refund total
- Status (select): "Published"
Notion – Block: Append — append a rich text block to the new page with a formatted summary paragraph.
Slack node — notify #metrics channel with the Notion page URL.

Gotcha: Notion page IDs from Page: Create are returned in the response as id. Use {{ $json.id }} in Block: Append to reference the just-created page.

Pattern 3: Notion-Triggered Fulfillment Workflow

Use case: Your team manages client project approvals in Notion. When a project page's Status property changes to "Approved", automatically send the client a welcome email, create a Trello card for the team, and update a Google Sheet.

Notion doesn't support real-time webhooks natively — you'll poll with the Schedule Trigger and check for recently-updated records.

Workflow:

Schedule Trigger — every 5 minutes.
Notion – Database: Query — filter for pages where Status = "Approved" AND Last Edited Time is after your last-check timestamp (store this in a Set node or a simple n8n static variable).
IF node — skip if results are empty.
Split In Batches node — process each newly-approved project one at a time.
Resend node — send welcome email to {{ $json.properties.Client_Email.email }}.
HTTP Request node — Trello API: create a card in the "Active Projects" list.
Google Sheets node — append a row to the project tracker sheet.
Notion – Page: Update — set Automation_Sent checkbox to true so re-runs skip this record.

Key config: The Automation_Sent checkbox flag is the dedup mechanism. Without it, every poll cycle re-processes all "Approved" records.

6 Common Gotchas

1. You must connect the integration to each page/database explicitly
Even if your integration has the right capabilities, Notion requires you to manually share each database or page with the integration via ⋯ → Add connections. "Not found" errors are almost always this. Fix: share the database with your integration in Notion's UI.

2. Title property is always required for Page: Create
Every Notion page has exactly one title property. You must set it — its name varies by database (could be "Name", "Title", "Task", etc.). Map it under the title input, not as an additional field.

3. Rich text values are arrays of text objects, not plain strings
When reading page content, rich text properties return [{ "plain_text": "...", "annotations": {...} }]. To get the plain string value: {{ $json.properties.Notes.rich_text[0].plain_text }}. For multi-block rich text: map and join.

4. Formula and rollup fields are read-only
You can read computed values from formula/rollup fields, but writing to them throws an error. Only update fields whose source data lives in that page.

5. Notion rate limits: 3 requests/second per integration
Loops over large databases will hit rate limits quickly. Add a Wait node (400ms) between iterations, or use Database: Query pagination (page_size max 100) and the has_more / next_cursor response fields to paginate manually.

6. Archived pages don't appear in Database: Query by default
If a page was archived, it won't show up in query results (Notion excludes archived records). To fetch archived pages, you need to hit the Search endpoint directly via HTTP Request. For most use cases, just make sure you're not accidentally archiving records you still need.

Free Workflow JSON

This implements Pattern 1 (Webhook → Notion CRM sync with dedup). Import via n8n → Import from JSON.

{
  "name": "Webhook → Notion CRM Sync (Dedup)",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "notion-crm-intake",
        "responseMode": "responseNode"
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "operation": "query",
        "databaseId": "YOUR_NOTION_DATABASE_ID",
        "filterJson": "={ \"property\": \"Email\", \"email\": { \"equals\": \"{{ $json.body.email }}\" } }"
      },
      "name": "Search Existing Lead",
      "type": "n8n-nodes-base.notion",
      "typeVersion": 2,
      "position": [460, 300]
    },
    {
      "parameters": {
        "conditions": {
          "number": [{ "value1": "={{ $json.results.length }}", "operation": "larger", "value2": 0 }]
        }
      },
      "name": "Lead Exists?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [680, 300]
    },
    {
      "parameters": {
        "operation": "create",
        "databaseId": "YOUR_NOTION_DATABASE_ID",
        "title": "={{ $('Webhook').item.json.body.name }}",
        "propertiesUi": {
          "propertyValues": [
            { "key": "Email", "emailValue": "={{ $('Webhook').item.json.body.email }}" },
            { "key": "Company", "textValue": "={{ $('Webhook').item.json.body.company }}" },
            { "key": "Status", "selectValue": "New" }
          ]
        }
      },
      "name": "Create New Lead",
      "type": "n8n-nodes-base.notion",
      "typeVersion": 2,
      "position": [900, 400]
    },
    {
      "parameters": {
        "operation": "update",
        "pageId": "={{ $json.results[0].id }}",
        "propertiesUi": {
          "propertyValues": [
            { "key": "Last Seen", "dateValue": "={{ $now.toISO() }}" }
          ]
        }
      },
      "name": "Update Last Seen",
      "type": "n8n-nodes-base.notion",
      "typeVersion": 2,
      "position": [900, 200]
    }
  ],
  "connections": {
    "Webhook": { "main": [[{ "node": "Search Existing Lead", "type": "main", "index": 0 }]] },
    "Search Existing Lead": { "main": [[{ "node": "Lead Exists?", "type": "main", "index": 0 }]] },
    "Lead Exists?": {
      "main": [
        [{ "node": "Update Last Seen", "type": "main", "index": 0 }],
        [{ "node": "Create New Lead", "type": "main", "index": 0 }]
      ]
    }
  }
}

Replace YOUR_NOTION_DATABASE_ID with your database ID and configure your Notion API credential.

Wrapping Up

The n8n Notion node covers the full database lifecycle — querying, creating, updating, and archiving pages. The patterns with the highest leverage are the sync patterns: pulling data from other systems into Notion as a structured record store, and using Notion as a lightweight approval layer that triggers downstream automation. The gotcha that bites most new users: sharing the integration with each database in Notion's UI — "not found" errors are almost always a missing connection grant, not a credential problem.

Want the full n8n Workflow Starter Pack? 25+ production-ready workflow templates covering lead capture, Stripe automation, AI pipelines, and more — $29 on Gumroad.

Need a custom n8n workflow built for your business? Done-for-you service — $99. Describe your automation, get a working workflow delivered.

n8n Airtable Node: Advanced Patterns for CRM Sync, Approval Flows, and Multi-Table Joins (Free Workflow JSON)

Pirate Prentice — Mon, 13 Jul 2026 07:21:07 +0000

n8n Airtable Node: Advanced Patterns for CRM Sync, Approval Flows, and Multi-Table Joins (Free Workflow JSON)

Airtable sits at a sweet spot between spreadsheet and database — flexible enough for non-technical teams to manage, structured enough for automation. The n8n Airtable node connects your Airtable bases directly to your automation stack, letting you read records, write new ones, update fields, and delete stale data programmatically.

This guide goes beyond basic CRUD to cover the patterns that actually show up in production: CRM sync, record approval flows, and joining data across multiple Airtable tables.

Prerequisites

n8n (self-hosted or cloud)
An Airtable account with at least one base
An Airtable Personal Access Token (PAT) — create one at airtable.com/create/tokens

Scopes you need on the PAT: data.records:read, data.records:write, schema.bases:read

In n8n: Credentials → New → Airtable Token API → paste your PAT.

Operations at a Glance

Operation	What It Does
Create Record	Add a new row to a table
Get Record	Fetch one record by its Airtable record ID
Get Many Records	List records with optional filtering, sorting, and field selection
Update Record	Overwrite specified fields on an existing record
Upsert Record	Create or update based on a field match
Delete Record	Remove a record by ID
Search	Find records matching a formula filter

Key Configuration Concepts

Finding Your Base ID and Table Name

Your Base ID is in the Airtable URL: https://airtable.com/appXXXXXXXXXXXX/... — the appXXXXXXXXXXXX part. Your Table Name is the tab label in the interface.

In n8n v4+, the Airtable node has a dropdown to select Base and Table. Use it — it validates your credential scope and saves you from typo bugs.

Filter Formulas

Airtable uses its own formula syntax for filtering, identical to what you'd use in Airtable views. Examples:

{Status} = "Active" — string match
AND({Status} = "Active", {MRR} > 100) — compound filter
IS_AFTER({Created}, "2026-06-01") — date comparison
SEARCH("n8n", {Tags}) — substring search

Pass these as the Filter by Formula field in the Get Many Records operation.

3 Production Workflow Patterns

Pattern 1: Webhook-to-Airtable CRM Sync

Use case: A prospect fills out a Typeform, Tally, or your own form. You want them in an Airtable CRM base — but only once (no duplicates), and you want to route new vs. returning leads differently.

Workflow:

Webhook Trigger — receives the form submission (name, email, company, message).
Airtable – Search Records — filter formula: {Email} = "{{ $json.email }}". Returns matching records if this lead already exists.
IF node — checks {{ $json.length > 0 }} (lead exists) vs. empty result (new lead).
- True branch (existing lead): Airtable – Update Record — set Last Contact to today, append to a Notes field with the new message.
- False branch (new lead): Airtable – Create Record — write all fields; then send a Slack notification or welcome email via Resend.
Merge node — rejoin both branches for any shared post-processing (e.g., log to a Sheet, notify the sales owner).

Key config on Search:

Operation: Search
Filter Formula: {Email} = "{{ $json.email }}"
Fields to Retrieve: id, Email, Name, Last Contact, Notes

Pattern 2: Multi-Table Record Join

Use case: You have an Orders table and a Customers table in Airtable. An order comes in via webhook; you need to enrich it with customer data from the Customers table before writing it to a reporting sheet.

Airtable's linked record fields give you related record IDs, not values — you have to fetch those values yourself in n8n.

Workflow:

Webhook Trigger — receives order data (order ID, customer record ID, amount, SKU).
Airtable – Get Record (Customers table) — fetch the customer record using the linked record ID from step 1: {{ $json.customer_record_id }}.
Merge node (Combine mode: Keep All) — merges the order item with the customer record fields. Now you have { order_id, amount, sku, customer_name, customer_email, customer_tier } in one item.
Set node — normalize and rename fields as needed.
Google Sheets – Append Row — write the enriched row to your reporting sheet.
Airtable – Update Record (Orders table) — mark the order as Synced: true so re-runs skip it.

Why this matters: Airtable's native automations can't easily pull linked record fields across tables and push them elsewhere. n8n fills this gap cleanly.

Pattern 3: Airtable Record Approval Flow

Use case: A team member creates a record in Airtable (e.g., a vendor invoice, a content piece, a PTO request). A manager needs to approve it before a downstream action fires (pay the invoice, publish the content, update the HR system).

Workflow:

Airtable Trigger — listen for records where Status changes to Pending Approval. (Use the Airtable Trigger node — it polls every minute by default.)
Slack node (or Gmail) — send the manager a message: "New approval request: [Title]. Approve: {{ $env.N8N_WEBHOOK_URL }}/approve?id={{ $json.id }} | Reject: {{ $env.N8N_WEBHOOK_URL }}/reject?id={{ $json.id }}"
Wait node — pause execution waiting for the webhook callback (set a timeout, e.g., 48h).
Webhook node (resume trigger) — the manager clicks Approve or Reject, which hits the webhook.
Switch node — routes on {{ $json.query.action }}: approve or reject.
- Approve branch: Airtable – Update Record — set Status = "Approved". Fire the downstream action (e.g., send the invoice to accounting via email).
- Reject branch: Airtable – Update Record — set Status = "Rejected", write the rejection reason. Notify the submitter.

Gotcha on Wait node: n8n's Wait node supports resuming via webhook. In self-hosted n8n, your instance must be publicly accessible for the manager to click the resume URL. Use a tunnel (ngrok/Cloudflare Tunnel) in development.

6 Common Gotchas

1. Field names are case-sensitive and space-sensitive
{First Name} is not the same as {firstname}. If your filter returns no results, double-check the exact field name in Airtable — include spaces and capitalization exactly.

2. Linked record fields return arrays of record IDs, not values
If a field is a linked record type (e.g., Customer linked to a Customers table), the value you get is ["recXXXXXXXXXXXXXX"] — a record ID, not a name. Fetch the linked record separately with a Get Record operation to get its fields.

3. Rate limits: 5 requests/second per base
Airtable enforces 5 req/s per base. If you're looping over hundreds of records, add a Wait node (200ms) between iterations, or batch your reads with Get Many Records + an Item Lists node to avoid 429 errors.

4. Airtable Trigger polls, not webhooks
The n8n Airtable Trigger uses polling (every 1–60 minutes configurable), not true push webhooks. If you need near-real-time triggers, use Airtable's native automations to call an n8n Webhook Trigger instead — far faster than polling.

5. Record IDs are unstable across base copies
If you duplicate an Airtable base, record IDs change. Don't use record IDs as business keys in external systems — use a dedicated unique field (e.g., a UUID you generate on creation, or a formula field).

6. Empty select/multiselect fields return null, not an empty array
Check for null before trying to access select values: {{ $json.Tags ? $json.Tags.join(", ") : "" }}. Failing to null-check crashes the expression.

Free Workflow JSON

This implements Pattern 1 (Webhook → Airtable CRM sync with dedup). Import via n8n → Import from JSON.

{
  "name": "Webhook → Airtable CRM Sync (Dedup)",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "crm-intake",
        "responseMode": "responseNode"
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "operation": "search",
        "base": { "value": "YOUR_BASE_ID" },
        "table": { "value": "Leads" },
        "filterByFormula": "={Email} = \"{{ $json.body.email }}\""
      },
      "name": "Search Existing Lead",
      "type": "n8n-nodes-base.airtable",
      "typeVersion": 2,
      "position": [460, 300]
    },
    {
      "parameters": {
        "conditions": {
          "number": [{ "value1": "={{ $json.length }}", "operation": "larger", "value2": 0 }]
        }
      },
      "name": "Lead Exists?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [680, 300]
    },
    {
      "parameters": {
        "operation": "update",
        "base": { "value": "YOUR_BASE_ID" },
        "table": { "value": "Leads" },
        "id": "={{ $json.id }}",
        "columns": {
          "mappingMode": "defineBelow",
          "value": { "Last Contact": "={{ $now.toISO() }}" }
        }
      },
      "name": "Update Last Contact",
      "type": "n8n-nodes-base.airtable",
      "typeVersion": 2,
      "position": [900, 200]
    },
    {
      "parameters": {
        "operation": "create",
        "base": { "value": "YOUR_BASE_ID" },
        "table": { "value": "Leads" },
        "columns": {
          "mappingMode": "autoMapInputData"
        }
      },
      "name": "Create New Lead",
      "type": "n8n-nodes-base.airtable",
      "typeVersion": 2,
      "position": [900, 400]
    }
  ],
  "connections": {
    "Webhook": { "main": [[{ "node": "Search Existing Lead", "type": "main", "index": 0 }]] },
    "Search Existing Lead": { "main": [[{ "node": "Lead Exists?", "type": "main", "index": 0 }]] },
    "Lead Exists?": {
      "main": [
        [{ "node": "Update Last Contact", "type": "main", "index": 0 }],
        [{ "node": "Create New Lead", "type": "main", "index": 0 }]
      ]
    }
  }
}

Replace YOUR_BASE_ID with your Airtable base ID and configure your Airtable Token credential.

Wrapping Up

The n8n Airtable node handles the full record lifecycle — but the patterns that deliver the most value are the ones that bridge Airtable to other systems: enriching records from linked tables, deduplicating inbound webhook data, and building approval flows that Airtable's native automations can't express. The gotcha to internalize: linked record fields give you IDs, not values — always fetch the linked record when you need its data.

Want the full n8n Workflow Starter Pack? 25+ production-ready workflow templates covering lead capture, Stripe automation, AI pipelines, and more — $29 on Gumroad.

Need a custom n8n workflow built for your business? Done-for-you service — $99. Describe your automation, get a working workflow delivered.

n8n Google Sheets Node: Read, Write, and Sync Spreadsheet Data in Your Workflows (Free Workflow JSON)

Pirate Prentice — Sun, 12 Jul 2026 19:27:47 +0000

Google Sheets is the default data store for small teams everywhere — lead lists, inventory trackers, project logs, CRM lite, budget sheets. The n8n Google Sheets node connects those sheets directly to your automation stack, letting you read rows, append new records, update cells, and delete stale data without ever opening a browser.

This guide covers every operation, common gotchas, three production-ready workflow patterns, and a free workflow JSON you can import today.

Prerequisites

n8n (self-hosted or cloud)
A Google Cloud project with the Google Sheets API enabled
A Google OAuth2 credential configured in n8n (or a Service Account for server-to-server access)

Google OAuth2 setup: in n8n go to Credentials → New → Google Sheets OAuth2 API. You'll need a Client ID and Secret from your Google Cloud Console. Authorize the credential; n8n stores the refresh token for you.

Operations at a Glance

Operation	What It Does
Append or Update Row	Write new row, or update if a matching key exists
Append Row	Always add a new row at the end of the sheet
Clear	Clear a defined range of cells
Create	Create a new spreadsheet
Delete	Delete rows matching a filter
Get Row(s)	Read one or more rows
Update Row	Overwrite specific columns in existing rows

Operation Deep-Dive

Append Row

The simplest write operation. Adds one row per input item to the sheet.

Key parameters:

Spreadsheet ID — the ID from the sheet URL (everything between /d/ and /edit)
Sheet Name — the tab name (case-sensitive; defaults to "Sheet1")
Columns — map your n8n data fields to sheet column headers

Use Mapping Column Mode: Map Each Column Manually when your column headers differ from your workflow field names. Use Auto-Map when they match exactly.

Gotcha: Append Row always adds a new row even if the record already exists. Use "Append or Update Row" when you want upsert behavior.

Append or Update Row

The upsert operation. Searches for a row where a specified column matches a value; if found, updates it; if not, appends a new row.

Key parameter: Column to Match On — pick a unique identifier (email, order ID, customer ID). Without a unique key, every run appends duplicates.

Get Row(s)

Reads rows from a sheet. Two sub-modes:

Get Many Rows — returns all rows (or up to a limit). Great for reading an entire list for processing.
Get Row by Row Number — fetch a specific row by index (1-based).

Filters: You can add a filter to return only rows where a column equals/contains a value. This runs client-side in n8n (all rows are fetched, then filtered) — not a server-side query. For large sheets (10,000+ rows) this can be slow; consider a more structured data store for high-volume lookups.

Output: Each row becomes one n8n item. Column headers become field names.

Update Row

Updates specific columns in a row you identify by row number. Useful when you already know the row index from a previous "Get Row(s)" step.

Delete Row

Deletes rows matching a filter. Supports "Delete Row" by row number or by filter match.

Warning: Deletions shift row numbers. If you delete row 5 in a loop, the old row 6 becomes row 5. Process deletions in reverse order (bottom to top) or collect all row numbers first, then delete in one batch.

Clear

Clears a defined range (e.g., A2:Z1000) without deleting the header row. Useful for resetting a reporting sheet before rewriting it.

Authentication: OAuth2 vs Service Account

OAuth2 (user credential): easiest setup, tied to your personal Google account. Works fine for personal or small-team use. Token expires and refreshes automatically; if the authorizing user's account is deleted, automations break.

Service Account: a non-human Google identity. Better for production. Steps:

Create a Service Account in Google Cloud Console.
Download the JSON key file.
In Google Sheets, share the target spreadsheet with the service account's email address (looks like name@project.iam.gserviceaccount.com).
In n8n, create a Google Sheets Service Account credential and paste the JSON key.

Service accounts don't expire and aren't tied to a person — strongly preferred for server-to-server automation.

3 Production Workflow Patterns

Pattern 1: Typeform → Google Sheets Lead Capture with Deduplication

Use case: A Typeform captures leads. You want them in Sheets, but re-submissions shouldn't create duplicate rows.

Workflow:

Typeform Trigger — fires on new submission.
Google Sheets – Get Row(s) — read the lead list, filter by email column matching the submission email.
IF node — if the email already exists, skip; if not, continue.
Google Sheets – Append Row — write the new lead.
Gmail / Resend — send a welcome email.

Key config: In step 2, use Filters → Column email equals {{ $json.email }}. The IF node checks {{ $json["Google Sheets"].length }} > 0.

Pattern 2: Daily Stripe Revenue Sync to Google Sheets

Use case: Every morning, pull the prior day's Stripe charges and append them to a running revenue log in Sheets. Finance team reads the Sheet.

Workflow:

Schedule Trigger — runs daily at 7 AM.
Stripe – Get Charges — filter by created >= yesterday 00:00 UTC, < today 00:00 UTC. Paginate if needed.
Set node — normalize fields: date, amount_usd (divide cents by 100), customer_email, description, status.
Google Sheets – Append Row — write each charge to the revenue log tab.
Google Sheets – Update Row — update a summary tab: total yesterday, running month total (calculate with a Code node before writing).

Tip: Use a separate "Summary" tab with formulas referencing the raw log. Let Sheets do the aggregation; n8n just feeds the data.

Pattern 3: Google Sheets as a Workflow Config Store

Use case: Non-technical team members need to control workflow behavior (e.g., which keywords to monitor, which clients are active, what email subject lines to use) without touching n8n.

Workflow:

Schedule Trigger (or webhook trigger at workflow start).
Google Sheets – Get Row(s) — read a "Config" tab. Each row is a config key-value pair (key, value).
Code node — convert rows into a lookup object: { keyword: "n8n", recipient: "ops@company.com", ... }.
Subsequent nodes use {{ $node["Code"].json.keyword }} etc. as dynamic parameters.

Why this works: It gives stakeholders a UI (Sheets) without giving them n8n access. You update logic by changing a cell, not deploying code.

6 Common Gotchas

1. Column headers must exist before writing
The Sheets node maps data to column headers. If a column header doesn't exist in row 1, data for that field is silently dropped. Always set up your header row first.

2. Spreadsheet ID vs Sheet name
The Spreadsheet ID is the long string in the URL. The Sheet Name is the tab label (e.g., "Sheet1", "Leads", "Config"). These are different — confusing them breaks authentication silently (wrong spreadsheet) or returns empty data (wrong tab).

3. Rate limits: 300 requests/minute per project
Google Sheets API enforces a 300 req/min limit. If you're processing hundreds of rows in a loop, add a Wait node (0.2s) between iterations, or switch to batch writes. Hitting the limit returns a 429 and n8n retries with exponential backoff, but this can slow workflows significantly.

4. Empty rows are returned as items with no fields
"Get Row(s)" returns empty rows as items with no fields. Add an IF node after reading: {{ Object.keys($json).length > 0 }} to filter them out.

5. Type coercion: everything comes back as a string
Sheets stores numbers and dates as text when read via API without explicit type coercion. If you need a numeric value for math, parse it: {{ parseInt($json.amount) }} or {{ Number($json.price) }}. Dates come back as strings like "7/12/2026" — parse with Luxon in a Code node if you need proper date objects.

6. Concurrent writes cause race conditions
If two workflow executions try to append rows at the same time, you can get duplicate rows or missed writes. For high-concurrency scenarios, use an n8n queue (execution mode set to "Queue") or write to a staging area and merge with a single scheduled consolidation workflow.

Free Workflow JSON

This workflow implements Pattern 2 (daily Stripe → Sheets revenue sync). Import via n8n → Import from JSON.

{
  "name": "Daily Stripe Revenue → Google Sheets",
  "nodes": [
    {
      "parameters": {
        "rule": { "interval": [{ "triggerAtHour": 7 }] }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "resource": "charge",
        "operation": "getAll",
        "returnAll": true,
        "filters": {
          "created": {
            "gte": "={{ $now.minus({days:1}).startOf('day').toUnixInteger() }}",
            "lt": "={{ $now.startOf('day').toUnixInteger() }}"
          }
        }
      },
      "name": "Stripe - Get Yesterday Charges",
      "type": "n8n-nodes-base.stripe",
      "typeVersion": 1,
      "position": [460, 300]
    },
    {
      "parameters": {
        "values": {
          "string": [
            { "name": "date", "value": "={{ $json.created_formatted }}" },
            { "name": "customer_email", "value": "={{ $json.billing_details.email }}" },
            { "name": "description", "value": "={{ $json.description }}" },
            { "name": "status", "value": "={{ $json.status }}" }
          ],
          "number": [
            { "name": "amount_usd", "value": "={{ $json.amount / 100 }}" }
          ]
        }
      },
      "name": "Normalize Fields",
      "type": "n8n-nodes-base.set",
      "typeVersion": 2,
      "position": [680, 300]
    },
    {
      "parameters": {
        "operation": "append",
        "documentId": { "value": "YOUR_SPREADSHEET_ID" },
        "sheetName": { "value": "Revenue Log" },
        "columns": {
          "mappingMode": "autoMapInputData"
        }
      },
      "name": "Google Sheets - Append Revenue",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4,
      "position": [900, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": { "main": [[{ "node": "Stripe - Get Yesterday Charges", "type": "main", "index": 0 }]] },
    "Stripe - Get Yesterday Charges": { "main": [[{ "node": "Normalize Fields", "type": "main", "index": 0 }]] },
    "Normalize Fields": { "main": [[{ "node": "Google Sheets - Append Revenue", "type": "main", "index": 0 }]] }
  }
}

Replace YOUR_SPREADSHEET_ID with your actual spreadsheet ID and configure your Google Sheets and Stripe credentials.

Wrapping Up

The n8n Google Sheets node is one of the most-used integrations in the ecosystem for good reason — Sheets is where small-team data already lives. The key patterns that hold up in production: use Append or Update Row with a unique key to prevent duplicates, authenticate with a Service Account for stability, batch your writes to stay under rate limits, and keep a "Config" tab pattern in your back pocket for ops-managed dynamic parameters.

Want the full n8n Workflow Starter Pack? 25+ production-ready workflow templates covering lead capture, Stripe automation, AI pipelines, and more — $29 on Gumroad.

Need a custom n8n workflow built for your business? Done-for-you service — $99. Describe your automation, get a working workflow delivered.

n8n Stripe Webhooks: Handle Payment Events, Subscriptions, and Refunds Automatically (Free Workflow JSON)

Pirate Prentice — Sun, 12 Jul 2026 19:22:37 +0000

Stripe fires webhooks for every meaningful payment event: a charge succeeds, a subscription renews, a payment fails, a refund is issued. If your n8n workflow isn't listening to these, you're missing real-time signals you need to run your business.

This guide covers everything you need to build a production-ready Stripe webhook handler in n8n — from wiring up the endpoint to handling the five events that matter most.

What You'll Learn

How to create a Stripe webhook endpoint in n8n
How to verify the webhook signature (so only Stripe can trigger your workflow)
How to handle the five most important Stripe events
Three real workflow patterns: payment receipt, failed payment recovery, and subscription lifecycle

Prerequisites

n8n (self-hosted or cloud) with a publicly accessible URL
A Stripe account with API access
Stripe secret key and webhook signing secret (from Stripe Dashboard → Developers → Webhooks)

Step 1: Create the Webhook Trigger in n8n

Open n8n and create a new workflow
Add a Webhook node as the trigger
Set HTTP Method to POST
Copy the generated webhook URL — you'll add it to Stripe next
Set Response Mode to Immediately (Stripe expects a 200 within 30 seconds)

Important: If you're running n8n locally, Stripe can't reach localhost. Use ngrok or deploy to a cloud instance for testing.

Step 2: Register the Endpoint in Stripe

Go to Stripe Dashboard → Developers → Webhooks
Click Add endpoint
Paste your n8n webhook URL
Select the events you want to handle (start with the five below)
Save — Stripe will show you the Signing Secret (starts with whsec_)

Events to select:

payment_intent.succeeded
payment_intent.payment_failed
invoice.payment_succeeded
invoice.payment_failed
customer.subscription.deleted

Step 3: Verify the Webhook Signature

Stripe signs every webhook with an HMAC-SHA256 signature. Verifying it ensures your workflow only processes real Stripe events — not spoofed requests.

After the Webhook trigger node, add a Code node:

// Stripe signature verification
const stripe = require('crypto');

const payload = $input.first().json.body; // raw body as string
const sigHeader = $input.first().headers['stripe-signature'];
const secret = 'whsec_YOUR_SIGNING_SECRET'; // store in n8n credential

const parts = sigHeader.split(',').reduce((acc, part) => {
  const [key, val] = part.split('=');
  acc[key] = val;
  return acc;
}, {});

const timestamp = parts['t'];
const sig = parts['v1'];

const signedPayload = `${timestamp}.${payload}`;
const expectedSig = stripe
  .createHmac('sha256', secret)
  .update(signedPayload, 'utf8')
  .digest('hex');

if (expectedSig !== sig) {
  throw new Error('Invalid Stripe signature — request rejected');
}

// Parse the event
const event = JSON.parse(payload);
return [{ json: event }];

Gotcha: n8n's Webhook node parses the body by default. You need the raw body for signature verification. Set Binary Data to false and Raw Body to true in the Webhook node's options, then access $input.first().json.rawBody or the header equivalent depending on your n8n version.

In practice: for non-critical internal workflows, you can skip signature verification. For production customer-facing workflows, always verify.

Step 4: Route Events with a Switch Node

Add a Switch node after verification to route different event types:

Output 1: {{ $json.type }} equals payment_intent.succeeded
Output 2: {{ $json.type }} equals payment_intent.payment_failed
Output 3: {{ $json.type }} equals invoice.payment_succeeded
Output 4: {{ $json.type }} equals invoice.payment_failed
Output 5: {{ $json.type }} equals customer.subscription.deleted
Fallback output: everything else (log and ignore)

The Five Events That Matter

1. `payment_intent.succeeded` — One-Time Payment Confirmed

Fires when a customer completes a one-time charge. Use this to:

Trigger product delivery (email a download link, provision access)
Write the sale to Google Sheets or Airtable
Send a Slack notification to your team

Key fields:

$json.data.object.amount           // amount in cents
$json.data.object.currency         // e.g., "usd"
$json.data.object.receipt_email    // customer email
$json.data.object.metadata         // your custom fields

2. `payment_intent.payment_failed` — Charge Failed

Fires when a card is declined or a payment attempt fails. Use this to:

Send a "payment failed" email to the customer with a retry link
Pause their service access after N failed attempts
Alert your team for high-value orders

Key fields:

$json.data.object.last_payment_error.message   // e.g., "Your card was declined"
$json.data.object.last_payment_error.code      // e.g., "card_declined"

3. `invoice.payment_succeeded` — Subscription Renewal Paid

Fires every time a subscription invoice is paid — both the first charge and renewals. Use this to:

Extend the customer's access period in your database
Send a renewal receipt
Update your MRR tracking spreadsheet

Key fields:

$json.data.object.customer_email
$json.data.object.amount_paid
$json.data.object.subscription     // subscription ID
$json.data.object.period_end       // Unix timestamp of next renewal

4. `invoice.payment_failed` — Subscription Payment Failed

Fires when a recurring charge fails (expired card, insufficient funds). This is critical for retention — most involuntary churn is recoverable if you act fast.

Use this to:

Send a "please update your card" email immediately
Trigger a dunning sequence (Day 1 email, Day 4 SMS, Day 7 final notice)
Flag the customer in your CRM for manual follow-up

Key fields:

$json.data.object.customer_email
$json.data.object.next_payment_attempt   // Unix timestamp Stripe will retry
$json.data.object.attempt_count          // how many times Stripe has tried

5. `customer.subscription.deleted` — Subscription Cancelled

Fires when a subscription ends (cancellation at period end resolves here, not at cancel time). Use this to:

Revoke access
Send a cancellation confirmation + offboarding email
Trigger a win-back sequence after 7 days
Write to a churn tracking sheet

Key fields:

$json.data.object.customer          // customer ID
$json.data.object.cancel_at_period_end
$json.data.object.ended_at

Three Complete Workflow Patterns

Pattern 1: Automated Payment Receipt + Delivery

Webhook → Verify Signature → Switch (event type)
  └─ payment_intent.succeeded
       → Extract: email, amount, metadata.product_id
       → Gmail/Resend: send receipt + download link
       → Google Sheets: append row (date, email, amount, product)

Result: Every successful payment triggers a branded receipt and fulfillment email within seconds, with every sale recorded automatically.

Pattern 2: Failed Payment Recovery Sequence

Webhook → Verify Signature → Switch
  └─ invoice.payment_failed
       → IF attempt_count == 1: send "Heads up, card failed" email
       → IF attempt_count == 2: send "Last chance" email with update link
       → IF attempt_count >= 3: send to CRM as churned + pause access

Result: Automated dunning that recovers 20–40% of failed subscription payments without manual intervention.

Pattern 3: Subscription Lifecycle Tracker

Webhook → Verify Signature → Switch
  ├─ invoice.payment_succeeded → Sheets: upsert row (customer, status=active, last_paid=now)
  ├─ invoice.payment_failed    → Sheets: update row (status=past_due, attempts=N)
  └─ subscription.deleted      → Sheets: update row (status=cancelled, ended_at=now)
                                → Wait 7 days → Send win-back email

Result: A real-time subscription dashboard in Google Sheets with zero manual updates, plus automated win-back outreach.

Free Workflow JSON

Download the complete workflow JSON (Webhook trigger → Signature verification → Switch node routing → all 5 event handlers with Gmail/Sheets stubs):

Download free n8n Stripe Webhook workflow JSON →

Import it in n8n: Settings → Import from file. Add your Stripe credentials and webhook signing secret, activate, and you're live.

6 Gotchas to Know

Raw body requirement: Stripe signature verification requires the exact raw request body. If n8n parses the JSON before you can read it, the HMAC won't match. Check your n8n version's Webhook node options for "Raw Body."
30-second response window: Stripe marks a webhook as failed if it doesn't receive a 200 within 30 seconds. Use Response Mode: Immediately on the Webhook node and do the heavy work (Sheets writes, emails) after responding.
Idempotency: Stripe retries failed webhooks for up to 3 days. Your workflow will receive duplicate events. Add a check node that looks up the event.id in a Sheets or database table and skips processing if already handled.
livemode flag: Stripe sends both test and live events to the same endpoint if you use the same URL. Check $json.livemode === true at the top of your Switch node to avoid processing test events in production.
payment_intent.succeeded fires for subscriptions too: The first subscription charge fires both payment_intent.succeeded and invoice.payment_succeeded. Handle only one to avoid double-processing.
Metadata is your friend: Add metadata fields to your Stripe Payment Intents (product ID, user ID, plan name). They come through in webhook payloads and let you route fulfillment without additional API calls.

Want This Built For You?

If you'd rather have a working Stripe webhook workflow built to your exact spec — event types, routing logic, email templates, Sheets schema — I'll build it for you.

$99 Done-For-You n8n Workflow →

You fill out a short intake form describing what you need (which events, what actions, what integrations). I build and deliver the workflow JSON within 48 hours, tested and ready to import.

Also publishing free n8n workflow guides and automation templates at pirateprentice.gumroad.com — check there for the full library.

n8n Question and Answer Chain Node: Build Retrieval-Augmented Workflows with Any Document [Free Workflow JSON]

Pirate Prentice — Sun, 05 Jul 2026 01:28:15 +0000

The Question and Answer Chain node is n8n's built-in RAG (Retrieval-Augmented Generation) node. You connect it to a vector store, give it a user question, and it retrieves relevant document chunks, passes them to a language model, and returns a grounded answer — all without writing code.

This guide covers how the node works, the full wiring pattern, configuration options, the 6 gotchas that trip people up, and 3 production-ready workflow patterns with free JSON.

What the Question and Answer Chain Node Does

The QA Chain node implements the classic RAG pattern:

Retrieve — embed the user's question and query a vector store for semantically similar chunks
Augment — inject the retrieved chunks into a prompt as context
Generate — pass the augmented prompt to a language model and return the answer

The result is an answer that's grounded in your actual documents — not just a hallucinated LLM response.

Typical inputs:

User questions (from a webhook, form, or chat trigger)
A populated vector store (Pinecone, Qdrant, Weaviate, in-memory)

Typical outputs:

A text answer grounded in retrieved context
Optionally: source chunk metadata (which document the answer came from)

Node Wiring

The QA Chain has two mandatory sub-node connections:

[Question source — Webhook / Chat Trigger / Form Trigger]
          ↓
[Question and Answer Chain]
    ↑              ↑
[Chat Model]  [Vector Store Retriever]
                    ↑
              [Vector Store node]
              (Pinecone / Qdrant / Weaviate / In-Memory)

Required connections:

Chat Model — the LLM that generates the answer (OpenAI, Anthropic, Gemini, Ollama, etc.)
Vector Store Retriever — a retriever sub-node wrapping a populated vector store

How to connect the Vector Store Retriever:

Add a Vector Store node (e.g., Pinecone Vector Store)
Set it to Retrieve Documents (For Agent/Chain) mode
Connect it to the QA Chain's Vector Store Retriever input

Configuration Options

Query field

The field on the incoming item that contains the user's question. Default is query — if your question is in a different field (e.g., message, text, question), change this.

Number of documents to retrieve (Top K)

How many chunks to pull from the vector store per query. Default is typically 4. Higher values give the LLM more context but increase token cost and can dilute relevance. For most use cases, 3–6 works well.

Return source documents

When enabled, the node includes the source chunk metadata in the output — which document, page, or chunk the answer came from. Essential for citation-backed answers and debugging.

6 Gotchas

1. Your vector store must be pre-populated

The QA Chain retrieves from an existing vector store — it does not ingest documents. You need a separate ingestion workflow that embeds your documents and stores them. The QA Chain is read-only at query time.

2. The Embeddings model must match the ingestion model

When you query, n8n embeds the question using the Embeddings model connected to your Vector Store Retriever. This must be the same model (and same dimensions) used when you originally ingested the documents. Mismatched embeddings produce garbage retrieval — the cosine similarity scores will be meaningless.

3. Query field mismatch returns empty answers

If your incoming question is in message but the node is configured to read query, it passes an empty string to the vector store. The retriever returns no chunks, and the LLM answers from its training data alone (or returns "I don't know"). Always verify the Query field setting matches your actual data structure.

4. Chunk size affects answer quality

If chunks are too small (< 100 tokens), retrieved context is fragmented and the LLM can't synthesize a complete answer. If chunks are too large (> 1000 tokens), you hit context limits faster and pay more per query. 300–500 tokens per chunk with ~50-token overlap is a good default for most document types.

5. The LLM still hallucinates without guardrails

The QA Chain grounds the LLM in retrieved context, but it can still hallucinate if the retrieved chunks don't fully answer the question. Add an explicit instruction in your prompt to respond with "I don't have enough information to answer that" when context is insufficient. Some vector store + chain combos support this natively; check the node's prompt template options.

6. In-Memory Vector Store doesn't persist across executions

n8n's built-in in-memory vector store resets every workflow execution. It's useful for testing and single-run batch jobs but not for a live QA system where you want to query the same corpus repeatedly. For production, use Pinecone, Qdrant, or Weaviate.

3 Workflow Patterns

Pattern 1: Internal Knowledge Base Bot

Scenario: Your team has a Notion wiki, internal docs, or a Confluence space. You want a Slack or Teams bot that answers employee questions by searching the actual docs.

Flow:

Ingestion workflow (runs once or on schedule):

HTTP Request (fetch docs from Notion/Confluence API)
→ Code node (chunk text into ~400-token segments)
→ Embeddings node (OpenAI text-embedding-3-small)
→ Pinecone Vector Store (upsert chunks with metadata: doc_title, url, updated_at)

Query workflow (runs on each question):

Webhook Trigger (Slack slash command or Events API)
→ Question and Answer Chain
    ↑ Chat Model (GPT-4o or Claude)
    ↑ Pinecone Vector Store Retriever (Top K: 5, return source docs: on)
→ Code node (format answer + source links)
→ HTTP Request (POST reply to Slack)

Why it works: The ingestion workflow keeps the vector store fresh. The query workflow is stateless and fast — each Slack question triggers a live retrieval + generation cycle. Source doc metadata lets you include links in the answer.

Free JSON: Download the Knowledge Base Bot workflow →

Pattern 2: PDF Document Q&A (Customer-Facing)

Scenario: You have product manuals, compliance documents, or legal agreements as PDFs. Customers or internal users need to ask questions about specific documents without reading them end to end.

Flow:

Ingestion workflow:

HTTP Request (download PDF from URL or S3)
→ Extract From File node (read PDF as text)
→ Code node (chunk into 400-token segments, tag with doc_id metadata)
→ OpenAI Embeddings
→ Qdrant Vector Store (upsert with namespace = doc_id)

Query workflow:

Webhook Trigger (POST: { doc_id: "...", question: "..." })
→ Question and Answer Chain
    ↑ Chat Model
    ↑ Qdrant Vector Store Retriever (filter by doc_id namespace, Top K: 4)
→ HTTP Response (return answer JSON)

Why it works: Namespacing by doc_id lets you host thousands of documents in one vector store and scope each question to the relevant document. Users get answers grounded in the actual text, not a generic LLM response.

Free JSON: Download the PDF Q&A workflow →

Pattern 3: Support Ticket Auto-Responder

Scenario: Your support team has hundreds of resolved tickets with proven answers. When new tickets arrive, you want to auto-draft a response based on similar past answers, then route to a human for review before sending.

Flow:

Ingestion workflow (batch, run periodically):

HTTP Request (fetch resolved tickets from Zendesk/Linear API)
→ Filter node (only tickets with "resolved" + agent_rating > 4)
→ Code node (format as "Problem: ... Solution: ..." chunks)
→ Embeddings → Pinecone (upsert with ticket_id, category metadata)

Query workflow:

Webhook (new ticket created)
→ Question and Answer Chain
    ↑ Chat Model (with system prompt: "Draft a support reply based only on the provided context")
    ↑ Pinecone Retriever (Top K: 3, filter by ticket category)
→ HTTP Request (POST draft reply to Zendesk internal note)
→ Slack notification (agent review required)

Why it works: The LLM drafts based on proven past answers, not generic training data. Filtering by category improves retrieval precision. The human-in-the-loop step before sending keeps quality high.

Free JSON: Download the Support Auto-Responder workflow →

QA Chain vs Other n8n AI Nodes

Node	Best for
Question and Answer Chain	Grounded answers from a pre-built document corpus
Basic LLM Chain	Free-form text generation with no retrieval
AI Agent	Multi-step reasoning with dynamic tool calls
Information Extractor	Pulling specific fields from a single piece of text
Summarization Chain	Condensing long documents into shorter summaries

Use the QA Chain when you need answers grounded in your own documents. Use Basic LLM Chain when you're fine with the model's training knowledge alone.

Quick Reference

Node: Question and Answer Chain
Required sub-nodes:
  - Chat Model (mandatory)
  - Vector Store Retriever (mandatory — wraps a populated vector store)

Key settings:
  - Query field: must match incoming item field name
  - Top K: 3–6 chunks (tune for quality vs cost)
  - Return source documents: on for citation-backed answers

Gotchas:
  - Pre-populate your vector store in a separate ingestion workflow
  - Embeddings model must match between ingestion and query
  - In-memory vector store resets between executions
  - Add "I don't know" fallback instruction to your prompt
  - Verify Query field matches actual data structure
  - Chunk size: 300–500 tokens with overlap is a good default

Get the Free Workflow JSON

All three patterns above are included in the n8n Workflow Packs available on Gumroad. One download, instant access, plug the JSON into your n8n instance and go.

→ Download the n8n Workflow Pack

Found this useful? Drop a comment below — I'm especially curious what vector store you're using and what document corpus you're building QA over.

n8n Information Extractor Node: Extract Structured Data from Text Using AI — Free Workflow JSON

Pirate Prentice — Sat, 04 Jul 2026 23:25:22 +0000

The Information Extractor node is one of n8n's most practical AI nodes. You give it unstructured text — an email, a PDF snippet, a support ticket, a scraped web page — and it uses a language model to pull out exactly the fields you define. No regex. No brittle parsing. Just structured JSON out.

This guide covers everything: how the node works, schema definition, output modes, the 6 gotchas that trip people up, and 3 production-ready workflow patterns with free JSON.

What the Information Extractor Node Does

The Information Extractor node wraps LangChain's structured output capability. You define a JSON schema (field names + types + descriptions), pass in a text input, and the connected Chat Model fills in the schema. The output is a single n8n item with your extracted fields as top-level keys.

Typical inputs:

Email body text
PDF or document content (after passing through Extract From File)
Support ticket descriptions
Web page text (after HTML Extract or HTTP Request)
Form submission free-text fields
API response descriptions

Typical outputs:

Structured records ready for a database insert
Enriched lead data
Classified + tagged items
Parsed addresses, dates, names, amounts

Node Wiring

The Information Extractor is an AI node — it sits inside n8n's LangChain sub-graph and requires a Chat Model sub-node connected to it.

[Your text source]
       ↓
[Information Extractor]
       ↑ (Chat Model connection)
[OpenAI / Anthropic / Gemini Chat Model]
       ↓
[Next node — uses extracted fields]

Required connection: Chat Model (any: OpenAI, Anthropic Claude, Google Gemini, Ollama, etc.)

Optional connections:

Memory node (rarely needed for extraction tasks)

Schema Definition

This is where most of the work happens. You define your extraction schema inside the node's Attributes section.

Adding Attributes

Each attribute has:

Name — the output field key (e.g., customer_name, invoice_total)
Type — String, Number, Boolean, or Object (nested)
Description — critical: the LLM uses this to understand what to extract. Be specific.

Good vs Bad Descriptions

Field	Bad description	Good description
`amount`	"The amount"	"Total invoice amount as a number, excluding currency symbols and commas (e.g. 1250.00)"
`sentiment`	"Sentiment"	"Customer sentiment: exactly one of positive, negative, or neutral"
`date`	"The date"	"Invoice date in ISO 8601 format (YYYY-MM-DD). If no year, assume current year."

Rule: Write descriptions as if you're telling a smart intern exactly what to write in that field. Ambiguous descriptions produce inconsistent outputs.

Optional vs Required

By default, all attributes are optional — the LLM will return null for fields it can't find. You can mark fields as required; the model will try harder but may hallucinate if the data isn't there.

Output Mode

The node has one primary output mode: it emits one item per input item, with your defined fields added to (or replacing) the item's JSON.

The extracted fields appear at the top level of the output item's json object, accessible as:

{{ $json.customer_name }}
{{ $json.invoice_total }}
{{ $json.sentiment }}

6 Gotchas

1. The Chat Model connection is mandatory — and often forgotten

If you drop the Information Extractor node and run without wiring a Chat Model sub-node, you'll get a connection error. Always add the Chat Model sub-node first. It appears as a small input handle at the bottom of the node.

2. Input field selection matters

The node has an Input field where you specify which field from the incoming item contains the text to extract from. Default is often text. If your text is in body, content, or description, change this — otherwise the model gets an empty string and returns nulls.

3. Long texts hit context limits

The LLM must read your entire input text. Very long documents (PDFs, long emails) can exceed the model's context window. Pre-chunk with the Summarization Chain node or truncate with a Code node before feeding into the extractor. For multi-page PDFs, extract page by page.

4. Hallucination on missing fields

If a field genuinely doesn't exist in the text and you've marked it required, the model may fabricate a plausible-sounding value. For required fields where absence is meaningful, use Optional + check for null downstream rather than Required.

5. Nested objects need careful schema design

You can define Object-type attributes with nested keys, but the deeper the nesting, the more the model struggles to fill it correctly. Flatten your schema where possible; one level of nesting is usually fine, two levels degrades reliability.

6. Temperature and model choice affect consistency

Higher-temperature models produce more variable extractions. For structured extraction, use a model/temperature that favors precision over creativity. With OpenAI, gpt-4o-mini at temperature 0 is a reliable cost-effective choice. With Anthropic, claude-haiku-4-5 works well for simple schemas; use claude-sonnet-4-6 for complex ones.

3 Workflow Patterns

Pattern 1: Email Lead Extractor

Scenario: Inbound emails arrive at a support inbox. You want to extract lead data (name, company, use case, budget range) and write it to a CRM or Google Sheet.

Flow:

Gmail Trigger (new email)
  → Information Extractor
      Schema: sender_name (String), company (String), use_case (String), budget_range (String), urgency (String: low/medium/high)
      Input field: text (email body)
  → Google Sheets (append row) OR HTTP Request (POST to CRM API)

Why it works: Email bodies are unstructured but the signal is there. The extractor turns "Hi, I'm Jane from Acme Corp, we need to automate our invoice reconciliation, budget around $5k" into a clean structured record in one step.

Free JSON: Download the Email Lead Extractor workflow →

Pattern 2: Support Ticket Classifier and Router

Scenario: Support tickets come in via webhook (Typeform, Jotform, or your app). You want to extract the issue category, severity, and affected product, then route to the right Slack channel or Linear project.

Flow:

Webhook Trigger (new ticket)
  → Information Extractor
      Schema: issue_category (String: billing/technical/account/feature-request), severity (String: low/medium/high/critical), affected_product (String), customer_tier (String: free/pro/enterprise)
      Input field: description
  → Switch node (route on issue_category)
      → Slack #billing-support / #tech-support / etc.
      → Linear (create issue with extracted fields)

Why it works: Routing logic that used to require keyword matching or a full classification model becomes a 2-node pattern. The extracted severity and customer_tier drive SLA assignment downstream.

Free JSON: Download the Support Ticket Router workflow →

Pattern 3: Invoice Data Extractor (PDF → Database)

Scenario: You receive invoices as PDF attachments via email. You want to extract invoice number, vendor, date, line items total, and due date, then insert them into Postgres or Airtable for AP tracking.

Flow:

Gmail Trigger (attachment: PDF)
  → Extract From File node (Read PDF as text)
  → Information Extractor
      Schema: invoice_number (String), vendor_name (String), invoice_date (String: YYYY-MM-DD), total_amount (Number), due_date (String: YYYY-MM-DD), currency (String)
      Input field: text
  → Postgres node (INSERT) OR Airtable node (Create Record)
  → Gmail (Send confirmation reply to sender)

Why it works: PDF invoice parsing used to require paid OCR services or brittle regex. With n8n's Extract From File + Information Extractor, you get structured AP data from any invoice format in seconds — and it handles vendor-to-vendor format differences automatically.

Free JSON: Download the Invoice Extractor workflow →

Information Extractor vs Other AI Nodes

Node	Best for
Information Extractor	Structured field extraction from unstructured text
Basic LLM Chain	Free-form text generation, classification, summarization
Summarization Chain	Condensing long documents into shorter summaries
AI Agent	Multi-step reasoning, tool use, decisions
Sentiment Analysis (via LLM Chain)	Single-dimension classification

Use Information Extractor when you need specific named fields out of text. Use Basic LLM Chain when you need a free-form text response.

Quick Reference

Node: Information Extractor
Requires: Chat Model sub-node (mandatory)
Input field: configure to match your data field
Output: extracted fields added to item JSON

Schema tips:
- Name: snake_case, descriptive
- Type: String / Number / Boolean / Object
- Description: be specific — the LLM reads this

Gotchas:
- Wire Chat Model first
- Set correct Input field
- Chunk long texts before extracting
- Use Optional fields for data that may be absent
- Flatten nested schemas
- Low temperature = more consistent extraction

Get the Free Workflow JSON

All three patterns above are included in the n8n Workflow Packs available on Gumroad. One download, instant access, plug the JSON into your n8n instance and go.

→ Download the n8n Workflow Pack

Found this useful? Drop a comment below — I'm especially curious which extraction use case you're tackling and which model you're using.

n8n Summarization Chain Node: Summarize Long Documents and Web Pages in Your Workflows [Free Workflow JSON]

Pirate Prentice — Sat, 04 Jul 2026 19:27:25 +0000

n8n Summarization Chain Node: Summarize Long Documents and Web Pages in Your Workflows [Free Workflow JSON]

The Summarization Chain node in n8n lets you condense long text — PDFs, emails, web pages, transcripts, knowledge-base articles — into concise summaries using any supported language model, without writing a single line of code. This guide covers every setting, the three summarization strategies, common gotchas, and three ready-to-use workflow patterns you can copy today.

What the Summarization Chain Node Does

The Summarization Chain node wraps LangChain's summarization chain and exposes it as a native n8n node. You feed it a Document (from a Document Loader or a Convert-to-Document node), attach a Chat Model, and get back a summary string.

It handles chunking, token management, and multi-pass summarization automatically — no manual splitting required.

Required Inputs

Input	Required	Description
Chat Model	Yes	Any n8n-supported LLM (OpenAI, Anthropic, Mistral, Ollama, etc.)
Document	Yes	One or more Document objects (from Document Loader sub-nodes)

Important: The node accepts LangChain Document objects, not raw text strings. You must pass data through a Document Loader (Default Data Loader, PDF Loader, etc.) or use the convertToDocument expression helper.

Summarization Type (Strategy)

The node offers three strategies. Select in the Summarization Type dropdown.

1. Map Reduce (default — recommended for long documents)

Splits the document into chunks, summarizes each chunk independently ("map"), then summarizes all chunk summaries together ("reduce").

Best for: PDFs, long transcripts, knowledge-base articles, multi-page docs
Token cost: Moderate (each chunk + final reduce)
Quality: High — each chunk gets full model attention

Settings exposed:

Combine Map Summaries Prompt — prompt used in the reduce step (customize to add structure)

2. Refine

Processes chunks sequentially: summarizes the first chunk, then passes that summary + the next chunk to the model to produce a refined summary, repeating until done.

Best for: Narrative text where context flows chronologically (meeting transcripts, stories, emails)
Token cost: Higher — each step sees growing context
Quality: Coherent narrative output

Settings exposed:

Refine Prompt — the instruction given at each refinement step

3. Stuff

Stuffs all document content into a single prompt and summarizes in one pass.

Best for: Short documents that fit within the model's context window
Token cost: Lowest
Gotcha: Fails silently or hallucinates if the document exceeds the model's context limit. Only use for documents you know are short.

Prompt Customization

All three strategies expose prompt fields. The default prompts are generic ("Write a concise summary of the following…"). Override them to get structured output:

Summarize the following customer support ticket in 2–3 sentences.
Focus on: (1) the customer's core problem, (2) what was tried, (3) the resolution status.
Reply in plain text only.

Prompts use {text} as the placeholder for document content. Do not remove it.

Output

The node outputs a single item with one field:

{ "response": "Your summary text here..." }

Access it downstream with {{ $json.response }}.

6 Common Gotchas

1. Passing raw text instead of a Document object
The node rejects plain strings. Wrap raw text using a Document Loader node set to "Default Data Loader" with your text in the Data field, or use convertToDocument() in a Code node.

2. Stuff strategy context-window overflow
There is no automatic guard. If your text exceeds the model's context limit, the model truncates silently or errors. Use Map Reduce for anything longer than ~3,000 words.

3. No {text} placeholder in custom prompts
The node injects document content via {text}. If you remove this placeholder from a custom prompt, the model summarizes an empty string and returns generic filler.

4. Slow execution on Map Reduce with many chunks
Each chunk is a separate API call. A 50-page PDF with 1,500-token chunks and a Map Reduce strategy may make 20+ API calls. Watch rate limits and latency. Use a faster/cheaper model (e.g., GPT-4o-mini, claude-haiku) for the map step.

5. Document Loader node required — not an HTTP Request node output
You cannot directly connect an HTTP Request node to the Document input. You need a Document Loader (e.g., the "Default Data Loader" or "PDF Loader" sub-node) between them.

6. Summarization Chain vs Basic LLM Chain for summarization
You can summarize with a Basic LLM Chain by passing text in the prompt — but you must handle chunking yourself. The Summarization Chain handles chunking automatically. For documents that reliably fit in context, Basic LLM Chain is simpler; for variable-length documents, always use Summarization Chain.

3 Workflow Patterns

Pattern 1: PDF Inbox Summarizer → Slack

Trigger: Gmail Attachment Trigger (PDF received)
→ Download attachment (HTTP Request or Gmail node)
→ Default Data Loader (PDF Loader)
→ Summarization Chain (Map Reduce, custom prompt: "Summarize this document in 5 bullet points, focusing on action items.")
→ Slack node (post to #documents channel with {{ $json.response }})

Use case: Legal, finance, and ops teams get instant Slack summaries of every inbound PDF without opening the file.

Pattern 2: Customer Support Ticket Summarizer

Trigger: Webhook (new ticket from Zendesk/Freshdesk)
→ Default Data Loader (ticket body + thread history as text)
→ Summarization Chain (Stuff — tickets are short; Map Reduce for long threads)
→ HTTP Request (PATCH ticket — write summary to custom field)

Use case: Agents see a 2-sentence summary at the top of every ticket before reading the thread. Cuts handle time.

Pattern 3: Nightly News Digest

Trigger: Schedule Trigger (daily at 6 AM)
→ RSS Feed Read node (10+ tech feeds)
→ Split In Batches (process each article URL)
→ HTTP Request (fetch article HTML)
→ HTML Extract (extract body text)
→ Default Data Loader
→ Summarization Chain (Map Reduce, prompt: "Summarize this article in 3 sentences. Include the main claim and any data points.")
→ Aggregate (collect all summaries)
→ Basic LLM Chain (combine into a single digest email)
→ Send Email (Gmail node)

Use case: Daily digest of 10 articles in under 30 minutes of reading — all AI-summarized.

Free Workflow JSON

Here is a minimal Summarization Chain workflow you can import directly into n8n:

{
  "name": "Summarization Chain — Starter",
  "nodes": [
    {
      "parameters": {},
      "name": "When clicking 'Test workflow'",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "dataType": "defineBelow",
        "jsonData": "=Your long text goes here. Replace this with {{ $json.body }} or any text field from an upstream node."
      },
      "name": "Default Data Loader",
      "type": "@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
      "typeVersion": 1,
      "position": [500, 420]
    },
    {
      "parameters": {
        "model": "gpt-4o-mini"
      },
      "name": "OpenAI Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1,
      "position": [500, 180]
    },
    {
      "parameters": {
        "summarizationMethodAndPrompts": {
          "summarizationMethod": "mapReduce"
        }
      },
      "name": "Summarization Chain",
      "type": "@n8n/n8n-nodes-langchain.chainSummarization",
      "typeVersion": 2,
      "position": [750, 300]
    }
  ],
  "connections": {
    "When clicking 'Test workflow'": {
      "main": [[{ "node": "Summarization Chain", "type": "main", "index": 0 }]]
    },
    "Default Data Loader": {
      "ai_document": [[{ "node": "Summarization Chain", "type": "ai_document", "index": 0 }]]
    },
    "OpenAI Chat Model": {
      "ai_languageModel": [[{ "node": "Summarization Chain", "type": "ai_languageModel", "index": 0 }]]
    }
  }
}

Want a complete implementation of any of the three patterns above? The n8n Workflow Starter Pack includes production-ready versions of all three patterns with error handling, retry logic, and Slack/email delivery built in.

Summarization Chain vs Other n8n Nodes

Node	Best For	Chunking	Output
Summarization Chain	Long documents of any length	Automatic	Summary string
Basic LLM Chain	Short text, custom prompts	Manual	Any LLM output
AI Agent node	Multi-step reasoning, tool calls	Manual	Agent response
Information Extractor	Structured data from text	None	JSON schema

Key Takeaways

Use Map Reduce for anything over ~3,000 words
Use Refine for narrative content where sequence matters
Use Stuff only for short, known-length documents
Always customize the prompt — the default is generic
Output is always {{ $json.response }}
Pair with Document Loaders, not raw text nodes

The Summarization Chain is the cleanest way to add document intelligence to any n8n workflow without managing chunking, token limits, or multi-step prompts yourself.

Building document processing pipelines with n8n? The n8n Workflow Starter Pack includes production-ready summarization workflows for PDF inboxes, support ticket summarizers, and nightly news digests — $29, instant download.

n8n Basic LLM Chain Node: Add Language Model Text Generation to Any Workflow [Free Workflow JSON]

Pirate Prentice — Sat, 04 Jul 2026 19:23:32 +0000

n8n Basic LLM Chain Node: Add Language Model Text Generation to Any Workflow [Free Workflow JSON]

tags: n8n, automation, ai, javascript

The n8n Basic LLM Chain node is the simplest way to add language model text generation to an n8n workflow. You wire it to any Chat Model node (OpenAI, Anthropic, Google, Ollama, etc.), pass it a prompt, and get a text response back — no agent loop, no tool calls, no memory overhead.

This guide covers every configuration option, the gotchas that catch people out, three production-ready patterns, and a free workflow JSON you can import today.

What the Basic LLM Chain node does

The Basic LLM Chain is a LangChain wrapper that executes a single prompt → response cycle:

Takes one or more input items (text, data fields, whatever your workflow has produced)
Builds a prompt from a template you define (with access to all input fields via {{ $json.fieldName }})
Sends it to a connected Chat Model sub-node
Returns the model's text response as { "text": "..." } on each output item

It does not loop, call tools, use memory, or reason across steps. For those, use the AI Agent node. The Basic LLM Chain is for single-shot generation: summarise, classify, extract, rewrite, translate, score.

Node anatomy

Required sub-node: Chat Model

The Basic LLM Chain has no built-in model. You must attach a Chat Model node as a child:

OpenAI Chat Model — GPT-4o, GPT-4o-mini, etc.
Anthropic Chat Model — claude-opus-4, claude-sonnet-4-6, claude-haiku-4-5
Google Gemini Chat Model — gemini-2.5-flash, gemini-2.5-pro
Ollama Chat Model — local models (llama3, mistral, etc.)
Azure OpenAI Chat Model — enterprise Azure deployments
Mistral Cloud Chat Model, Cohere, Groq, and others

Drag the Chat Model node onto the canvas, then connect it to the Basic LLM Chain's AI Language Model input (the purple connector).

Optional sub-node: Output Parser

By default, the chain returns raw text in { "text": "..." }. If you need structured output (JSON, a list, a specific schema), attach an Output Parser:

Structured Output Parser — define a Zod/JSON schema; the model is instructed to return JSON matching it
Auto-fixing Output Parser — wraps another parser; if the model returns malformed JSON it sends a correction prompt automatically
List Output Parser — returns a simple array of strings
Item List Output Parser — splits a comma/newline-separated list into individual items
Bytes Output Parser — returns raw bytes (rare)

Prompt template

The main configuration field is the Prompt (or User Message if using a chat-style template). This is a Mustache/Handlebars-style template with access to the current item's fields:

Summarise the following support ticket in one sentence. Be concise.

Ticket subject: {{ $json.subject }}
Ticket body: {{ $json.body }}

n8n evaluates {{ $json.fieldName }} at runtime for each item, so one chain node handles batches automatically.

System message

An optional System Message field sets the model's persona/instructions. Keep it short and direct:

You are a helpful assistant. Respond only in plain text with no markdown formatting.

Temperature and other model params

Temperature, max tokens, top-p, and stop sequences are configured on the Chat Model sub-node, not on the Basic LLM Chain itself. Adjust them there.

Gotchas

1. You must wire a Chat Model — the node won't run without one
The Basic LLM Chain has no fallback model. If the AI Language Model input is unwired, execution fails immediately. Always connect a Chat Model sub-node first.

2. {{ $json }} in prompts — not {{ $item.json }}
Inside the Prompt field, n8n uses Mustache syntax. The correct reference is {{ $json.fieldName }}, not the expression syntax {{ $item.json.fieldName }} used in other node fields. Using expression syntax here produces literal text, not the value.

3. Output is always { "text": "..." } unless you attach an Output Parser
Downstream nodes expecting a field like summary or category won't find it. Either attach an Output Parser, or add a Set node after the chain to rename text to your preferred field name.

4. One LLM call per input item
The Basic LLM Chain runs once per input item. If your upstream node produces 500 items, you'll make 500 model calls. For large batches, add a Split In Batches node upstream and respect rate limits on the model sub-node.

5. Context window limits
If you're passing long documents into the prompt, watch token counts. The chain doesn't chunk automatically. For long-document summarisation, use the Summarization Chain node instead — it handles chunking and map-reduce strategies.

6. The chain returns a new item, not a merged item
The output item contains only { "text": "..." } (or your parsed output). Input fields are not automatically carried forward. Use a Merge node to join the chain's output back to the original item if you need both.

Three production-ready patterns

Pattern 1: Support ticket classifier

Classify incoming support tickets by category and urgency so they can be routed without human triage.

Workflow:
Webhook Trigger → Basic LLM Chain (+ OpenAI Chat Model + Structured Output Parser) → Switch node → Slack/email routing

Prompt:

Classify this support ticket.

Subject: {{ $json.subject }}
Body: {{ $json.body }}

Return JSON with:
- category: one of ["billing", "technical", "account", "general"]
- urgency: one of ["low", "medium", "high"]
- one_line_summary: string (max 15 words)

Structured Output Parser schema:

{
  "category": "string",
  "urgency": "string",
  "one_line_summary": "string"
}

Downstream: Switch node routes on urgency → Slack alert for "high", Zendesk ticket for "medium"/"low".

Pattern 2: Blog post meta generator

Given a draft blog post body, generate SEO title, meta description, and 5 tags automatically before publishing.

Workflow:
Google Drive Trigger (new file) → Google Drive node (read content) → Basic LLM Chain (+ Anthropic Chat Model + Structured Output Parser) → Google Sheets node (write metadata row) → Notify

Prompt:

You are an SEO copywriter. Given the blog post below, generate:
- An SEO title (max 60 characters, front-load the main keyword)
- A meta description (max 155 characters, include a call to action)
- Five relevant tags (lowercase, hyphenated)

Blog post:
{{ $json.content }}

Structured Output Parser schema:

{
  "seo_title": "string",
  "meta_description": "string",
  "tags": ["string"]
}

This pattern runs zero-cost on haiku/flash for short posts; reserve Sonnet/GPT-4o for posts where quality matters most.

Pattern 3: Customer review sentiment + response draft

Process incoming product reviews: extract sentiment, key themes, and draft a personalised response — ready for a human to approve before sending.

Workflow:
Schedule Trigger → HTTP Request (fetch reviews from API) → Split Out (one item per review) → Basic LLM Chain (+ Claude Haiku + Structured Output Parser) → Google Sheets append → Slack digest

Prompt:

Analyse this product review and draft a response.

Review ({{ $json.rating }} stars):
{{ $json.review_text }}
Product: {{ $json.product_name }}

Return:
- sentiment: "positive" | "neutral" | "negative"
- themes: array of up to 3 key themes mentioned
- response_draft: a polite, personalised 2-3 sentence response from the brand

The response draft goes into Sheets; a Slack digest shows the day's reviews with one-click links to approve/edit responses. The human touches only the outliers.

Free workflow JSON

Import this into n8n (Workflows → Import from clipboard) to get a working Basic LLM Chain skeleton with a Webhook trigger, chain, and Structured Output Parser wired up:

{
  "name": "Basic LLM Chain — Starter",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "llm-chain",
        "responseMode": "responseNode"
      },
      "id": "webhook-1",
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [240, 300]
    },
    {
      "parameters": {
        "prompt": "={{ $json.prompt }}",
        "options": {}
      },
      "id": "llm-chain-1",
      "name": "Basic LLM Chain",
      "type": "@n8n/n8n-nodes-langchain.chainLlm",
      "typeVersion": 1.4,
      "position": [460, 300]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ { \"result\": $json.text } }}"
      },
      "id": "respond-1",
      "name": "Respond to Webhook",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [680, 300]
    }
  ],
  "connections": {
    "Webhook": {
      "main": [[{"node": "Basic LLM Chain", "type": "main", "index": 0}]]
    },
    "Basic LLM Chain": {
      "main": [[{"node": "Respond to Webhook", "type": "main", "index": 0}]]
    }
  }
}

Note: After importing, add your Chat Model sub-node (e.g. OpenAI Chat Model) connected to the Basic LLM Chain's AI Language Model input. The workflow won't run without it.

When to use Basic LLM Chain vs AI Agent

Use case	Basic LLM Chain	AI Agent
Single prompt → text response	✅	overkill
Classify / summarise / extract	✅	overkill
Structured JSON output	✅ (+ Output Parser)	✅
Multi-step reasoning	❌	✅
Tool calls (web search, APIs)	❌	✅
Conversation memory	❌	✅
Cheaper / faster	✅	❌

Rule of thumb: if you can write the task as a single prompt, use the Basic LLM Chain. If the task requires the model to decide what to do next, use an AI Agent.

Quick-start checklist

[ ] Add a Chat Model sub-node and connect it to the Basic LLM Chain's purple input
[ ] Write your prompt using {{ $json.fieldName }} for dynamic values
Add an Output Parser sub-node for structured output
[ ] Add a Set node downstream if you need to rename text to a specific field
[ ] Test with a single item before running on large batches
[ ] Set temperature and max tokens on the Chat Model sub-node

The Basic LLM Chain is n8n's workhorse for single-shot AI tasks. Wire it once, feed it your data, and every item in your workflow gets an LLM pass — classification, summarisation, extraction, drafting — without touching the agent complexity. Start here, move to the AI Agent only when you genuinely need it.

n8n Execute Workflow Node: Call Sub-Workflows and Build Modular Automations [Free Workflow JSON]

Pirate Prentice — Sat, 04 Jul 2026 15:25:43 +0000

The n8n Execute Workflow node lets one workflow call another workflow as a sub-routine. It's the foundation of modular n8n architecture: instead of one giant workflow that does everything, you build small, tested, reusable workflows and compose them together.

This guide covers every configuration option, the gotchas that trip people up, three production-ready patterns, and a free workflow JSON.

What the Execute Workflow node does

The Execute Workflow node synchronously calls another n8n workflow and waits for it to finish. The called workflow runs, produces output, and that output lands in the calling workflow as items — just like data from any other node.

This unlocks:

Modular design — shared logic lives in one place, called from many workflows
Reusable sub-routines — auth checks, data transforms, notification dispatchers
Testable units — test and debug each sub-workflow independently
Loop control — use Execute Workflow inside a Split In Batches loop to call logic per item

Trigger requirement in the called workflow

The called workflow must have an Execute Workflow Trigger node as its entry point (not a Webhook or Schedule Trigger). This trigger receives the data passed by the parent workflow.

Parent workflow → Execute Workflow node → Called workflow (starts at Execute Workflow Trigger)

If the called workflow starts with any other trigger, n8n won't know where to inject the input data.

Configuration parameters

Parameter	What it does
Source	Where to find the workflow to call: Database (by workflow ID from the same n8n instance), Define below (inline workflow JSON, for testing). Use Database in production.
Workflow ID	The numeric ID of the workflow to execute. Find it in the URL when you open the workflow in the n8n editor: `/workflow/12345`.
Wait for Sub-Workflow Completion	Toggle. On (default) = the parent waits for the child to finish and receives its output. Off = fire-and-forget, no output returned.
Fields to pass	Which fields from the current item to send to the child workflow. Leave empty to pass all fields.
Run Once with All Items	Off (default) = the child workflow is called once per item (loops over your dataset). On = the child is called once with all items together (bulk mode).

Data flow

Parent → Child:
The items flowing into the Execute Workflow node are passed to the Execute Workflow Trigger in the child. Use {{ $json.fieldName }} expressions inside the child workflow to access them.

Child → Parent:
Whatever the child workflow's last node outputs becomes the output of the Execute Workflow node in the parent. Shape the child's output with a Set node at the end if you need a consistent schema.

Gotchas & common errors

1. The called workflow must be active

The Execute Workflow node calls the workflow by ID — but if the called workflow is deactivated (or has never been saved/activated), it will fail. Keep shared sub-workflows in "active" state even if they don't have a schedule or webhook.

2. Workflow ID changes on export/import

If you export a workflow and re-import it (to a new n8n instance or environment), it gets a new ID. Hard-coded workflow IDs in Execute Workflow nodes will break. Use environment variables or a lookup mechanism for the ID in multi-environment setups.

3. Infinite loops

If Workflow A calls Workflow B, and Workflow B calls Workflow A, you'll create an infinite loop that will exhaust memory. n8n doesn't detect this automatically. Sketch your workflow dependency graph before building.

4. Error propagation

Errors thrown inside the child workflow propagate to the parent and cause the Execute Workflow node to error. If you want the parent to continue even when the child fails, wrap the Execute Workflow node in an Error Trigger or set up a Try/Catch pattern with the workflow's Error Trigger workflow.

5. Run Once with All Items changes the output shape

In per-item mode (default), each child execution returns one item. In bulk mode (Run Once with All Items), the child receives all items at once and returns all its output items. This can change the downstream item count unexpectedly if you're not aware of which mode is active.

6. Credentials are not inherited

The child workflow runs with its own credentials. If the child calls an API, it needs its own credential configured — it won't use the parent's credentials.

3 workflow patterns

Pattern 1: Shared notification dispatcher

[Any workflow] → Execute Workflow ("Send Notification" sub-workflow)
  Input: { channel: "slack", message: "...", level: "error" }

"Send Notification" sub-workflow:
  Execute Workflow Trigger
  → Switch node (route on {{ $json.channel }}: slack | email | telegram)
  → Branch A: Slack node (send to #alerts)
  → Branch B: Gmail node (send to ops@company.com)
  → Branch C: Telegram node (send to ops chat)

Use case: One notification workflow, called from 20 different workflows. Change the notification logic in one place.

Pattern 2: Reusable data enrichment

CRM webhook (new contact) → Execute Workflow ("Enrich Contact")
  Input: { email, company_name }

"Enrich Contact" sub-workflow:
  Execute Workflow Trigger
  → HTTP Request (fetch company data from Clearbit/Apollo)
  → HTTP Request (check LinkedIn via SerpApi)
  → Set node (normalise output schema)
  → [returns enriched contact object to parent]

Parent continues:
  → Airtable (update contact record with enriched data)

Use case: Reuse the same enrichment logic from your CRM webhook, your bulk import workflow, and your nightly refresh — without duplicating nodes.

Pattern 3: Batch processor with per-item sub-workflow

Schedule Trigger (nightly)
→ Postgres (SELECT id, email FROM users WHERE needs_report = true)
→ Split In Batches (batch size: 10)
  → Execute Workflow ("Generate User Report")
    Input: { user_id, email }

"Generate User Report" sub-workflow:
  Execute Workflow Trigger
  → Postgres (SELECT user's activity data)
  → Basic LLM Chain (Anthropic: generate personalised summary)
  → Resend (send email to user)
  → Postgres (UPDATE users SET report_sent_at = NOW())

Use case: Process 500 users nightly, each getting a personalised AI report, without building a 40-node monolith.

Free workflow JSON

Shared notification dispatcher pattern:

{
  "name": "Notification Dispatcher (Sub-Workflow)",
  "nodes": [
    {
      "parameters": {},
      "name": "Execute Workflow Trigger",
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "position": [240, 300]
    },
    {
      "parameters": {
        "rules": {
          "values": [
            { "outputKey": "slack", "conditions": { "options": { "version": 2 }, "combinator": "and", "conditions": [{ "leftValue": "={{ $json.channel }}", "rightValue": "slack", "operator": { "type": "string", "operation": "equals" } }] } },
            { "outputKey": "email", "conditions": { "options": { "version": 2 }, "combinator": "and", "conditions": [{ "leftValue": "={{ $json.channel }}", "rightValue": "email", "operator": { "type": "string", "operation": "equals" } }] } }
          ]
        },
        "options": {}
      },
      "name": "Route by Channel",
      "type": "n8n-nodes-base.switch",
      "position": [460, 300]
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            { "id": "1", "name": "sent", "value": true, "type": "boolean" },
            { "id": "2", "name": "channel", "value": "={{ $json.channel }}", "type": "string" }
          ]
        },
        "options": {}
      },
      "name": "Mark Sent",
      "type": "n8n-nodes-base.set",
      "position": [680, 300]
    }
  ],
  "connections": {
    "Execute Workflow Trigger": {
      "main": [[{ "node": "Route by Channel", "type": "main", "index": 0 }]]
    },
    "Route by Channel": {
      "main": [
        [{ "node": "Mark Sent", "type": "main", "index": 0 }],
        [{ "node": "Mark Sent", "type": "main", "index": 0 }]
      ]
    }
  }
}

Import via Settings → Import from URL/Clipboard. Add your Slack/Gmail nodes between the Switch output and Mark Sent. Note the workflow ID after saving, then reference it in your parent workflows' Execute Workflow nodes.

Next steps

Use with the n8n Split In Batches node for scalable batch processing
Pair with the n8n AI Agent node — the n8n Workflow Tool uses Execute Workflow under the hood
Add n8n Error Trigger to handle sub-workflow failures gracefully
Browse the full n8n Workflow Starter Pack for pre-built modular automation patterns

Are you using Execute Workflow to build modular n8n architectures? Share your sub-workflow patterns in the comments — especially if you've solved the multi-environment ID problem.

DEV Community: Pirate Prentice

n8n GitHub Node: Automate Issues, Pull Requests, and Releases in Your Workflows [Free Workflow JSON]

What the n8n GitHub Node Can Do

Credentials Setup

Six Common Gotchas

Three Production-Ready Workflow Patterns

Pattern 1: GitHub Issue → Slack + Linear Triage Bot

Pattern 2: Release Notes Auto-Publisher

Pattern 3: PR Quality Gate Notifier

Free Workflow JSON

GitHub Node vs. HTTP Request Node

Putting It All Together

n8n Shopify Node: Automate Orders, Customers, and Inventory in Your Workflows [Free Workflow JSON]

n8n Shopify Node: Automate Orders, Customers, and Inventory in Your Workflows [Free Workflow JSON]

What the n8n Shopify Node Can Do

Prerequisites

Creating the credential in n8n

The Six Gotchas That Will Bite You

1. The API rate limit is 40 requests/second — not per minute

2. "Get All" has a default limit of 250 records — pagination is manual

3. Order financial_status vs fulfillment_status — they're independent

4. Webhooks need a public URL — use ngrok or a cloud n8n instance for development

5. Webhook deduplication is your responsibility

6. Customer email is not always present

Pattern 1: Order → Google Sheets Revenue Sync

Pattern 2: Low-Stock Alert → Slack + Supplier Email

Pattern 3: New Order → CRM Contact Sync + Tag Enrichment

Shopify Node vs HTTP Request Node (GraphQL)

Free Workflow JSON

Where to Go From Here

Get the Pre-Built n8n Workflow Pack

n8n HubSpot Node: Sync Contacts, Deals, and Companies in Your Workflows (Free Workflow JSON)

n8n HubSpot Node: Sync Contacts, Deals, and Companies in Your Workflows (Free Workflow JSON)

What the HubSpot Node Does

Operations Reference

Contact Operations

Company Operations

Deal Operations

Ticket Operations

Association Operations

Authentication: Private App Token

Six Gotchas

Workflow Pattern 1: Typeform Lead → HubSpot Contact + Deal

Workflow Pattern 2: HubSpot Deal Stage Change → Slack Alert + Google Sheet Log

Workflow Pattern 3: Stripe Payment → HubSpot Contact Update + Note

Free Workflow JSON

HubSpot Node vs. HTTP Request Node

Key Takeaways

What to Read Next

n8n Notion Node: Sync Databases, Manage Pages, and Build Automated Workflows (Free Workflow JSON)

Prerequisites

Operations at a Glance

Key Configuration Concepts

Finding Your Database ID

Property Types Matter

Filtering in Database: Query

3 Production Workflow Patterns

Pattern 1: CRM-to-Notion Database Sync

Pattern 2: Automated Weekly KPI Report to Notion

Pattern 3: Notion-Triggered Fulfillment Workflow

6 Common Gotchas

Free Workflow JSON

Wrapping Up

n8n Airtable Node: Advanced Patterns for CRM Sync, Approval Flows, and Multi-Table Joins (Free Workflow JSON)

n8n Airtable Node: Advanced Patterns for CRM Sync, Approval Flows, and Multi-Table Joins (Free Workflow JSON)

Prerequisites

Operations at a Glance

Key Configuration Concepts

Finding Your Base ID and Table Name

Filter Formulas

3 Production Workflow Patterns

Pattern 1: Webhook-to-Airtable CRM Sync

Pattern 2: Multi-Table Record Join

Pattern 3: Airtable Record Approval Flow

6 Common Gotchas

Free Workflow JSON

Wrapping Up

n8n Google Sheets Node: Read, Write, and Sync Spreadsheet Data in Your Workflows (Free Workflow JSON)

Prerequisites

Operations at a Glance

1. `payment_intent.succeeded` — One-Time Payment Confirmed

2. `payment_intent.payment_failed` — Charge Failed

3. `invoice.payment_succeeded` — Subscription Renewal Paid

4. `invoice.payment_failed` — Subscription Payment Failed

5. `customer.subscription.deleted` — Subscription Cancelled