10 n8n Workflow Templates for SaaS Founders

The short answer: yes, n8n is genuinely useful for SaaS founders in 2026. It is a fair-code workflow platform with 1,500+ first-party integrations, 10,648 community templates (n8n.io, as of July 2026), and an execution-based pricing model that one provider compared to running 100,000-step workflows for about $50/month on Pro (n8n blog, August 2023 - pricing still valid on the current plan page). The ten templates below are ones I’ve shipped or watched ship in real early-stage SaaS shops, with verified node names, sample JSON, and a cost estimate you can sanity-check against n8n’s published tiers.

The big idea: SaaS operations is a graph of events - signups, trials, payments, tickets, churn risks - and n8n is a tool for joining that graph with HTTP calls, AI calls, and human checkpoints. Each template below is one join.

n8n 101: what you’re getting into in 2026

n8n is a fair-code, Node.js-based workflow automation platform. I think of it as “Zapier you can actually fork and host yourself” with deep data-engineering primitives like Postgres triggers, HTTP Request nodes, and a built-in Code node for JavaScript or Python. The current stable line is n8n 2.29.8 / 2.30.4 (release list, GitHub n8n-io/n8n, July 2026).

n8n measures pricing in workflow executions, not steps. One full run from trigger to last node counts as one execution, no matter how many nodes it touches. That matters for SaaS founders because a single webhook chain can pull a record, branch on a condition, call three APIs, and write back to your CRM without inflating your bill. The published model is straightforward (n8n pricing page, confirmed July 2026):

Plan	Price (annual)	Executions	Concurrent	Notes
Community (self-host)	Free	Unlimited	Your hardware	Source-available under the Sustainable Use License
Starter (Cloud)	€20/mo	2,500	5	1 project, 2,300 AI credits/mo
Pro (Cloud)	€50/mo	10,000	20	3 projects, up to 13,700 AI credits/mo, global variables, 7-day insights
Business (Cloud or self-host)	€667/mo	40,000	200+	6 projects, SSO/SAML/LDAP, Git versioning, 30-day insights
Enterprise	Contact sales	Custom	200+	External secret stores, log streaming, dedicated SLA

Cloud data sits in Frankfurt, Germany per the pricing FAQ (July 2026). Self-hosted runs wherever you do - Docker, bare metal, Kubernetes, or npx n8n for the brave. For deployments against a real production load, the official install docs recommend Docker with Postgres.

The nodes you’ll touch most often: webhook, schedule, HTTP Request, Code, If, Switch, Merge, Edit Fields (Set), Postgres, Stripe, Slack, HubSpot, Linear, OpenAI/Anthropic, Twilio, Sentry, Notion, Gmail, Google Sheets, and Resend. Every one of these is documented at docs.n8n.io and the operations match the vendor’s actual API surface (I cross-verified the Stripe, Slack, HubSpot, Linear, Sentry, OpenAI, Anthropic, Twilio, and Postgres nodes individually against the vendor docs - see Sources).

AI Assistant note for 2026: the bundled AI Assistant (Preview) is included on all n8n Cloud plans and consumes a monthly credit allowance (2,300 on Starter, up to 13,700 on Pro). On self-hosted you bring your own API key (n8n docs).

The 10-template playbook at a glance

Before I walk through each one, here’s the whole list. Each row links to the underlying node docs I used for the configuration.

#	Template	Trigger	Key integrations	Steps (nodes)	What it replaces (manual hours/week)
1	AI lead enrichment + routing	Webhook (form submit)	Clearbit / HTTP, OpenAI or Anthropic, Slack, HubSpot	7	5–8
2	Self-serve trial onboarding	Webhook (signup event)	Stripe, Postgres, Resend, Slack	9	6–10
3	Stripe → CRM sync	Stripe webhook	Stripe, Postgres, HubSpot	5	3–5
4	MRR + arr snapshot	Schedule (daily 06:00)	Stripe, Postgres, Slack	7	2–3
5	Trial → paid nudges	Schedule (daily)	Stripe, Postgres, Resend, Slack	8	4
6	Billing dunning bot	Stripe webhook	Stripe, Resend, Slack, Postgres	8	6
7	Churn save agent	Postgres trigger + AI	Postgres, Anthropic Claude, Slack, HubSpot	10	5
8	NPS follow-up loop	Webhook (survey)	Postgres, Resend, Linear, Slack	8	3
9	Security log triage (Sentry → Slack)	Sentry webhook	Sentry, Slack, Linear	6	4
10	Weekly founder ops report	Schedule (Mondays 09:00)	Stripe, Postgres, HubSpot, OpenAI, Slack	11	3–4

The “manual hours/week” column is rough - it’s the time a human ops person would spend clicking around to do the same job, based on what founders I work with report. The point isn’t precision, it’s that each template pays for itself in the first week.

---

1. AI lead enrichment + routing

What it does: the moment a high-intent form submission hits your webhook, this flow enriches the email, classifies the lead with an LLM, posts a heads-up to Slack, and creates a clean contact in HubSpot. Sales gets to a routed lead inside ~30 seconds without anyone copy-pasting between tabs.

Trigger: Webhook node (POST) on the “Request a Demo” form.

Nodes used: Webhook → HTTP Request (Clearbit-style enrichment) → Code (light normalization) → OpenAI Chat Model (or Anthropic node) → Set → Slack → HubSpot.

Step-by-step sketch:

1. Webhook node receives {email, company, name, source} (max payload 16 MB per n8n Webhook docs).
2. HTTP Request hits an enrichment API (Clearbit is a first-party node; Apollo is HTTP only).
3. Edit Fields (Set) builds the prompt input.
4. OpenAI Chat Model subnode (or Anthropic Messages API node) returns a JSON object: {"intent":"hot|warm|cold","score":0..1,"reasoning":"..."}. I always set response_format to JSON via the Responses API (OpenAI function-calling docs).
5. Switch node routes hot leads to #sales-inbound, warm leads to #marketing-nurture.
6. HubSpot node creates or updates the contact with Create/Update Contact (n8n HubSpot docs, which calls the HubSpot CRM Contacts API).

Sample JSON - OpenAI Chat Model subnode config (production-ready pattern):

{
  "modelId": "gpt-5.6",
  "options": {
    "temperature": 0.2,
    "responseFormat": {
      "type": "json_schema",
      "json_schema": {
        "type": "object",
        "properties": {
          "intent": { "type": "string", "enum": ["hot", "warm", "cold"] },
          "score": { "type": "number" },
          "reasoning": { "type": "string" }
        },
        "required": ["intent", "score", "reasoning"]
      }
    }
  },
  "messages": [
    {
      "role": "system",
      "content": "You classify B2B SaaS demo requests. Hot = tier-1 fit, named budget, in market. Warm = ICP fit, no budget signal. Cold = student, job seeker, or unrelated."
    },
    {
      "role": "user",
      "content": "={{ JSON.stringify($json) }}"
    }
  ]
}

Deploy & cost: template ships as a sub-workflow or as a single workflow with an Error Workflow attached. Pro Plan (€50/mo annual, 10K executions) covers up to ~800 hot leads a month before tiering up. API cost: roughly $0.001–$0.01 per lead on gpt-5.6-mini, similar on Claude Haiku. See n8n’s execution-pricing explainer on how complex a single execution can be before it actually costs you.

---

2. Self-serve trial onboarding

What it does: when a new trial is created, the workflow provisions their account, sends a welcome email through Resend, schedules a check-in for day three, and posts a “new trial started” message to the team channel. Replaces the half-day of manual setup most early teams do.

Trigger: Stripe subscription created webhook, or a Postgres trigger from your app’s users table.

Nodes used: Webhook (Stripe) or Postgres Trigger → If (plan == trial) → Edit Fields → Resend → Postgres (set trial_end_at, plan_tier) → Slack (notify success).

Step-by-step sketch:

1. Stripe webhook comes in with customer.subscription.created per Stripe events docs.
2. If node checks status == "trialing" (the Stripe subscriptions list page documents the status field semantics).
3. Resend node posts a branded email (the Resend Send Email API supports idempotency keys via the Idempotency-Key header, max 50 recipients per call).
4. Postgres node Insert writes trial_started_at, plan_tier, company_size (verified against n8n Postgres docs).
5. Wait node (n8n docs) pauses the workflow until day 3 - supports time-interval or webhook-resume.
6. Slack DM via the Send and Wait for Response operation on the Slack node (n8n Slack docs) - yes, you can pause until a human replies.

Sample JSON - Postgres insert of trial start row:

{
  "operation": "insert",
  "schema": "public",
  "table": "trials",
  "columns": "stripe_customer_id, email, plan_tier, trial_started_at, trial_ends_at, status",
  "values": "={{ [$json.customer, $json.email, $json.plan, $now.toISO(), $now.plus({days:14}).toISO(), 'active'] }}",
  "returnFields": "*"
}

Deploy & cost: runs once per trial signup. Self-host on Community Edition and you’re paying only for Resend (cheap - first 3,000 emails/month free on their current tiered pricing) and Postgres. On Cloud Starter you get 2,500 executions/month for €20 - fine for early-stage.

---

3. Stripe → HubSpot (and Postgres) sync

What it does: every Stripe event becomes a Postgres fact row plus a HubSpot deal update. Your “source of truth” stays Postgres (cheap to query, scripted), while sales sees the same state in HubSpot (where they live).

Trigger: Stripe webhook → n8n Webhook node.

Nodes used: Webhook → If (event.type in allowed list) → Set → Postgres (Insert or Update) → HubSpot (Update Deal / Create Deal).

Step-by-step sketch:

1. Stripe webhook posts events like customer.subscription.updated and invoice.payment_succeeded (the Stripe webhook docs spell out the 30-day event-API window and the IP allowlist requirement).
2. If node filters to only subscription + invoice events.
3. Stripe node (n8n docs) Customer Get retrieves canonical email and metadata.
4. Postgres Insert or Update writes to billing_events (operation list, including Insert or Update, is documented in the same page).
5. HubSpot Update Deal moves the deal to a stage that matches the new status.

Sample JSON - Stripe event verification helper for the Webhook node:

{
  "httpMethod": "POST",
  "path": "stripe-billing",
  "responseMode": "onReceived",
  "options": {
    "rawBody": true
  }
}

You then add a Code node that calls Stripe’s signature verification (Stripe.webhooks.constructEvent) - confirmed against the verify-webhook-signatures section of the docs. n8n’s Webhook node accepts raw body when Raw Body option is enabled.

Deploy & cost: one execution per Stripe event, executed at the volume Stripe pushes events to your endpoint. Stripe retries for up to 3 days in live mode per the webhook delivery doc, so add idempotency - write the Stripe event.id to Postgres before doing anything else.

---

4. Daily MRR + ARR snapshot

What it does: every weekday morning, this fires, asks Stripe for current MRR (you compute it from active subscription totals), writes the snapshot to Postgres, and posts a single clean number to #founders with delta vs. yesterday.

Trigger: Schedule Trigger - every weekday at 06:00 (cron 0 6 * * 1-5 per the n8n Schedule Trigger docs).

Nodes used: Schedule Trigger → Stripe (Subscription Get Many) → Code (sum MRR + new + churn) → Postgres (Insert into mrr_snapshots) → Slack (post formatted message).

Step-by-step sketch:

1. Schedule Trigger fires - beware: n8n docs note that variable values in cron expressions are only re-evaluated on publish. Don’t change them and expect them to take.
2. Stripe Subscription → Get Many with status: "active" filter.
3. Code node aggregates monthly recurring revenue, normalized across multi-currency via the Stripe unit_amount decimals.
4. Postgres Insert.
5. Slack Send Message posts the formatted text using blocks (the Slack chat.postMessage API accepts text up to 4,000 chars and blocks for richer layouts).
6. An Error Trigger workflow (n8n docs) catches anything that fails.

Sample JSON - Slack message for the daily MRR post:

{
  "channel": "#founders",
  "text": "MRR {{ $json.mrr | number:0 }} • Δ {{ $json.delta | number:0 }} • ARR {{ $json.arr | number:0 }} • Active subs {{ $json.active }}",
  "blocks": [
    {
      "type": "section",
      "text": { "type": "mrkdwn", "text": "*Daily SaaS Pulse* - :chart_with_upwards_trend: MRR *{{ $json.mrr }}* • New *{{ $json.new }}* • Churn *{{ $json.churn }}*" }
    }
  ]
}

Deploy & cost: one execution per day is basically free on any plan. This is a calm heartbeat to install early.

---

5. Trial → paid conversion nudges

What it does: as the trial window crosses 75%, 90%, and 100%, the user gets a personalized email with usage stats. If they don’t convert, sales gets a ping.

Trigger: Schedule Trigger daily, looking for trials approaching expiry. Or a Postgres trigger that fires when trial_ends_at - now() < 3 days.

Nodes used: Schedule → Postgres Select → If (in trial window) → HTTP Request (your app’s usage API) → Resend (or Linear + Slack for sales notification).

Step-by-step sketch:

1. Postgres Select where trial_ends_at between now() and now() + interval '3 days'.
2. HTTP Request hits your app’s /api/usage/:user_id for last-7-day numbers.
3. Resend sends the email with usage.
4. If node branches on whether the user has converted (you can hit /api/billing/status).
5. If no conversion at T-1, Slack posts to #sales-fu with a one-click “send personal reply” action.

Why this works: Resend templates support up to 50 string variables per template. Use them aggressively - the email content stays stable while the numbers change.

Deploy & cost: schedules count as executions, but a once-daily Cron that produces zero work (no trials expiring) still counts once. Add a Schedule Trigger that runs at 06:00 only.

---

6. Billing dunning (failed-payment rescue)

What it does: when Stripe fails to charge a card, customers usually churn silently. This workflow retries the email reminders Stripe sends by default, but adds your voice, your data, and your support team.

Trigger: Stripe webhook on invoice.payment_failed (documented in Stripe’s events list).

Nodes used: Webhook → Stripe (Invoice Get) → If (attempt_count == 1, 3, 5) → Resend (different templates at each step) → Slack (DM your support lead at attempt 4) → Linear (create a “billing-risk” issue at attempt 5).

Sample JSON - Resend send with idempotency key:

{
  "from": "billing@yourcompany.com",
  "to": ["={{ $json.customer_email }}"],
  "subject": "Your subscription needs a quick update",
  "html": "={{ $json.recovery_email_html }}",
  "headers": {
    "Idempotency-Key": "={{ `dunning-${ $json.invoice_id }-${ $json.attempt_count }` }}"
  }
}

The Resend Idempotency-Key header is documented in their Send Email reference (24-hour expiry, max 256 chars). It prevents double-sending if Stripe retries the webhook mid-recovery - see Stripe’s automatic-retry behavior in their webhooks doc.

Deploy & cost: expected volume = small percentage of MRR. On Enterprise this is the single highest-ROI workflow.

---

7. Churn save agent (AI-assisted)

What it does: pings you when usage drops off a cliff. Combines a Postgres change-detection trigger with an LLM that drafts a save email, then routes to either the AI generated copy or to a human CSM depending on tier.

Trigger: Postgres Trigger node (n8n-nodes-base.postgrestrigger) firing on usage_daily when a 7-day moving average falls >50%.

Nodes used: Postgres Trigger → Aggregate (7-day rolling) → If (drop > threshold) → Anthropic Message a Model → If (tier == strategic) → Slack (human review) → Resend (auto-send for self-serve).

Step-by-step sketch:

1. Postgres Trigger captures the row delta. (Postgres Trigger node docs live under the trigger-nodes section.)
2. Aggregate node (n8n docs) computes weekly rollup.
3. If node sets the threshold. I default to “weekly active < 40% of trial peak” - tune per business.
4. Anthropic “Message a Model” operation (n8n Anthropic docs) writes the save email. Use the Anthropic Messages API with structured outputs (the structured-outputs doc shows you how to constrain JSON via output_config.format).
5. If strategic tier → Slack DM “needs your eyes” → wait for reply → Resend.
6. If self-serve → auto-Resend with cancel link.

Sample JSON - Anthropic structured-output prompt:

{
  "model": "claude-sonnet-5",
  "max_tokens": 800,
  "system": "You are a SaaS customer-success copywriter. Produce JSON: subject, body, offer_type, offer_value.",
  "messages": [
    {
      "role": "user",
      "content": "={{ `Usage drop detected for ${ $json.company }. Last 14 days of events: ${ $json.events }` }}"
    }
  ],
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {
          "subject": { "type": "string" },
          "body": { "type": "string" },
          "offer_type": { "type": "string", "enum": ["none", "discount", "extension"] }
        }
      }
    }
  }
}

The Anthropic Messages API supports structured JSON outputs with output_config.format - verified in the Anthropic structured-outputs docs. Use strict: true if you want maximum schema guarantees.

Deploy & cost: only fires for at-risk accounts. Probably <50 events/month for most early-stage SaaS shops. The Anthropic Sonnet call is cheap; the SLA you’d lose without it is not.

---

8. NPS follow-up loop

What it does: every time someone responds to your NPS survey, the answer gets scored, written to Postgres, and - if they’re a detractor (0–6) or passives with complaints (7–8) - gets bucketed into Linear as a follow-up ticket.

Trigger: Webhook (Typeform, SurveyMonkey, or your own NPS page).

Nodes used: Webhook → Code (parse + classify) → Postgres Insert → Switch → Linear Create Issue (detractor) or Linear Add Comment (passive) or Slack cheer (promoter).

Sample JSON - Linear issue creation for a detractor:

{
  "team": "Customer Success",
  "title": "NPS detractor - {{ $json.company }} ({{ $json.score }})",
  "description": "{\"kind\":\"nps-detractor\",\"customer_id\":\"{{ $json.customer_id }}\",\"comment\":\"{{ $json.comment }}\",\"submitted_at\":\"{{ $json.timestamp }}\"}",
  "priority": 1,
  "labelIds": []
}

Linear is a GraphQL API (developer docs); n8n’s Linear node wraps it cleanly - confirmed operations include Issue Create, Issue Update, Issue Get Many in the Linear node docs. Be aware that Linear applies OAuth or personal-API-key auth and rate-limits aggressively; use a Loop Over Items / batch node if you import a backlog (the Split in Batches node is the right tool).

Deploy & cost: O(NPS responses). Bundles into any plan. Will keep annoying complaints from falling into your support inbox unnoticed.

---

9. Security log triage (Sentry → Slack)

What it does: the moment Sentry spots a new high-frequency error, it checks whether anyone on your team has been paged about it lately, and if not, posts a triage message to #engineering-oncall with the fingerprint and a Linear issue link already drafted.

Trigger: Sentry webhook on issue.alert or poll via Sentry Issue Get Many on a schedule.

Nodes used: Webhook (Sentry) → Code (dedupe on fingerprint) → Postgres (Check alerted_fingerprints table) → If (new) → Slack → Linear (Create) → Postgres (Insert fingerprint).

Sketch:

1. Sentry webhook posts the event. n8n’s Sentry.io node docs confirm operations: Issue Get Many, Issue Update, Event Get Many, plus Organization, Project, Release, and Team resources. The full Sentry REST API reference lives at docs.sentry.io/api (v0 - web API).
2. Code node computes a SHA-1 of issue.id + title to dedupe.
3. Postgres check: was this fingerprint alerted in the last 4 hours?
4. If yes → exit early (Silenced by previous run).
5. If no → Slack via chat.postMessage (note the 1 msg/sec/channel rate limit) → create Linear ticket → record fingerprint.

Sample JSON - Slack chat.postMessage adapted to n8n Slack node:

{
  "channel": "#engineering-oncall",
  "text": ":rotating_light: {{ $json.culprit }} - {{ $json.title }} (occurrences: {{ $json.count }})",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*{ { $json.title }}*\n{{ $json.culprit }} - {{ $json.count }} events in last hour\n<{{ $json.url }}|Sentry>  "
      }
    }
  ]
}

Slack’s Web API rate-limits chat.postMessage to roughly 1 message per second per channel; n8n’s Loop Over Items node helps when you’re ingesting a backlog (n8n docs). Required OAuth scopes per the Slack scopes reference include chat:write for the bot token.

Deploy & cost: negligible. Pro plan covers a busy day of error storms.

---

10. Weekly founder ops report

What it does: every Monday at 09:00, this builds and posts an end-to-end snapshot - new trials, conversion rate, activation milestones, MRR delta, paying customers added, paying customers churned, support tickets opened, bug alerts. One Slack thread, one Stripe-derived truth.

Trigger: Schedule Trigger - Mondays at 09:00 (cron 0 9 * * 1).

Nodes used: Schedule → Postgres (4 separate Selects for trials, paying, churned, tickets) → Stripe (Subscription Get Many) → Code (compose summary) → OpenAI Chat Model (write a 3-bullet “what changed this week” narrative) → Slack.

Step-by-step sketch:

1. Schedule Trigger fires Monday 09:00 (use a 0 9 * * 1 cron - examples in n8n Schedule docs).
2. Postgres Select (multiple branches merged with the Merge node’s Combine-by-Matching-Fields or by appending).
3. Stripe Subscription Get Many for active vs. last week.
4. Code node computes the delta.
5. OpenAI Chat Model subnode (using Responses API when you toggle it in the n8n UI) returns a 3-sentence narrative.
6. Slack posts to #founders.

Sample JSON - Postgres Select stub for new trials this week:

{
  "operation": "select",
  "schema": "public",
  "table": "trials",
  "where": {
    "clause": "started_at BETWEEN $1 AND $2",
    "params": ["={{ $now.minus({days:7}).toISO() }}", "={{ $now.toISO() }}"]
  },
  "returnFields": ["email", "company", "started_at", "plan_tier"]
}

Deploy & cost: one execution per week is free. This is the workflow that pays for everything else the moment you stop building it manually.

---

Best practices that hold across all 10

Idempotency keys everywhere. Stripe’s webhook retries for up to 3 days (docs). Resend supports an Idempotency-Key header (docs). OpenAI’s Responses API does not auto-deduplicate - track your own. The pattern: store (source, idempotency_key) in Postgres before doing the side effect, and check before re-running.

Always attach an error workflow. n8n’s Error Trigger node (docs) fires when a workflow errors. Set it once globally: Settings → Error Workflow. Make it post to Slack with execution.id, execution.url, lastNodeExecuted, and the error message. Saves 2 hours every time something breaks at 2 a.m.

Credentials live in n8n’s encrypted secrets store. Not in the workflow JSON. Not in environment variables if you don’t need to. The credentials database is encrypted with a key under ~/.n8n/config per the docs. For production, set your own encryption key with the env var pattern shown in set-a-custom-encryption-key - otherwise your data is encrypted with the default key and unrecoverable if the host dies.

Choose Postgres over SQLite when you grow past a single admin. Self-hosted n8n defaults to SQLite. Production should be Postgres: the official Docker recipe shows the env vars in install-with-docker (DB_TYPE=postgresdb, DB_POSTGRESDB_HOST=…, etc.).

HTTP Request + Predefined Credential Type is your escape hatch. When an integration lacks a node (or the node is missing an operation), the HTTP Request node can call any REST API and reuse the credential you defined for the service. n8n’s docs on custom API operations cover the pattern. I curl-import most external API contracts now - it’s faster than retyping GET/POST URL pairs.

The Code node vs. Code-naked debates die when you have 200+ saved executions. JavaScript in the Code node is fine. Heavy transforms should go to a Code node or a transform-in-Postgres. The Code node supports Node.js and Python (native, stable in 2.x per the n8n Code node docs).

Don’t use the Execute Command node on Cloud. It’s blocked there, in fact disabled by default since 2.0 even on self-hosted, per Execute Command docs. For shell access, use a Cloudflare Worker or a Vercel function called via HTTP Request instead. Cloudflare Workers docs confirm they’re free for the first 100K requests/day and run JS at the edge; Vercel Functions docs describe the same for Node/Python serverless.

Test webhooks before pushing live. Use the test URL the Webhook node exposes (n8n docs), not the production URL. The 16 MB payload limit matters for media-heavy workflows - anything bigger needs S3 first.

---

FAQ

Is n8n free in 2026? Community Edition (self-hosted) is free under the Sustainable Use License - unlimited executions on your own hardware. Cloud Starter is €20/month billed annually for hosted (currently 2,500 executions and 5 concurrent, per the n8n pricing page, verified July 2026). It is fair-code, not open source, but the source is visible and you can self-host indefinitely.

How does n8n pricing compare to Zapier or Make? Per the n8n blog’s execution-advantage post, n8n counts one full run as one execution regardless of step count, while competitors price per step or task. A 100,000-step workflow that costs roughly $500/month elsewhere fits in n8n’s Pro tier ($50/month annual) for the same number of runs - n8n pitch, December 2025 pricing, your mileage will vary.

Do I need to be a developer? The drag-and-drop editor handles 80% of what SaaS founders want. JS or Python in the Code node covers most of the remaining 20%. The data-structure docs (n8n work with data) explain items, linking, and expression syntax in plain language.

Is it safe for production? Yes, with caveats. Use Postgres, set a custom encryption key, put it behind HTTPS with valid certs (TLS 1.2 or 1.3 only, per the Stripe webhook requirements which generalize), and disable telemetry if compliance requires. The docs explain SSRF protection and 2FA enforcement at security config. Pro/Customer references: Vodafone, Trendyol, Stepstone, Huel, Icatu, Seguros Bolívar, Quid, Delivery Hero, Musixmatch, TMNZ, pxtra, Sanas, Koralplay, and many more (case studies index).

Does n8n handle RAG? Yes. Use Pinecone or Supabase as a vector store, the OpenAI/Anthropic chat model, and the AI Agent root node - exact operations are catalogued at n8n vector store docs (Pinecone) and the LangChain AI Agent docs.

What changes between self-host and Cloud? Cloud data is in Frankfurt under EU jurisdiction (n8n pricing, July 2026). On Cloud you can’t install community nodes that aren’t n8n-approved; on self-host you can. On Cloud you can’t use the Execute Command node. The Code node on Cloud only allows crypto and moment npm modules (per the Code node docs) - use a function-as-a-service for anything else.

---

Sources (verified July 2026)

n8n platform & pricing

• n8n pricing page (current tiers, July 2026)
• n8n workflows library index (10,648 templates)
• n8n case studies (Vodafone, Trendyol, Stepstone, Huel, Icatu, Seguros Bolívar, Delivery Hero, etc.)
• n8n blog - execution advantage explainer (Aug 2023)
• n8n blog home (July 2026)
• n8n-io GitHub repo (196k stars, current release 2.30.4)
• n8n docs - Choose how to use n8n
• n8n docs - Sustainable Use License
• n8n docs - Install with npm
• n8n docs - Install with Docker
• n8n docs - Configure n8n / env vars
• n8n docs - Security (encryption, 2FA, SSRF)
• n8n docs - Custom encryption key
• n8n docs - AI Assistant (Preview)

n8n node references (verified operation lists)

• Stripe node operations
• Slack node operations
• HubSpot node operations
• Postgres node operations
• Linear node operations
• Sentry.io node operations
• Twilio node operations
• Cloudflare node operations (zone certificates)
• Google Calendar node
• Gmail node
• Google Sheets node
• Google Drive node
• Notion node
• SendGrid node
• Airtable node
• Supabase node
• Mattermost node
• Zendesk node
• Discord node
• Intercom node
• Asana node
• Jira Software node
• GitHub node
• Microsoft Teams node
• OpenWeatherMap node
• Pinecone Vector Store node (cluster)
• OpenAI Chat Model subnode (Responses API support)
• OpenAI node (legacy chat + new)
• Anthropic node
• AI Agent root node
• Webhook core node
• Schedule Trigger core node
• Error Trigger core node
• Wait core node
• HTTP Request core node
• If core node
• Switch core node
• Merge core node
• Loop Over Items (Split in Batches) core node
• Aggregate core node
• Edit Fields (Set) core node
• Code core node
• Execute Command node (disabled by default in v2.0)
• Node types overview (core, cluster, community)

Vendor APIs (verified)

• Stripe API events reference
• Stripe webhooks docs (signature verification, retries up to 3 days)
• Stripe subscriptions reference (status, lifecycle)
• Stripe billing overview (Smart Retries, customer portal)
• OpenAI function calling guide (tool/function JSON schemas)
• Anthropic Messages API reference
• Anthropic structured outputs guide (output_config.format)
• Slack chat.postMessage method (chat:write scope, 4,000 chars text)
• Twilio Messages resource (160-char SMS limit, status callbacks)
• Resend Send Email API (Idempotency-Key header, max 50 recipients)
• Linear developers (GraphQL API, OAuth, rate limits)
• Sentry web API reference (v0)
• Cloudflare Workers docs (serverless functions, free tier)
• Vercel Functions docs (Fluid Compute, Node/Python runtimes)
• Pinecone docs (vector database overview)