diff --git a/.claude/plugins/n8n/skills/setup-experiment/SKILL.md b/.claude/plugins/n8n/skills/setup-experiment/SKILL.md
new file mode 100644
index 00000000000..a3334b09758
--- /dev/null
+++ b/.claude/plugins/n8n/skills/setup-experiment/SKILL.md
@@ -0,0 +1,14 @@
+---
+name: setup-experiment
+description: >-
+  Scaffolds new `packages/frontend/editor-ui` experiments using the n8n
+  experiment standard. Use when creating a new editor-ui experiment, adding a
+  PostHog experiment scaffold, or setting up experiment files for a new
+  experiment.
+---
+
+# Setup experiment
+
+Use this skill when scaffolding a new `packages/frontend/editor-ui` experiment.
+
+Follow [reference.md](reference.md) for the canonical workflow, scaffold rules, and output reminders.
diff --git a/.claude/plugins/n8n/skills/setup-experiment/reference.md b/.claude/plugins/n8n/skills/setup-experiment/reference.md
new file mode 100644
index 00000000000..1ae1d166aad
--- /dev/null
+++ b/.claude/plugins/n8n/skills/setup-experiment/reference.md
@@ -0,0 +1,140 @@
+# Setup experiment reference
+
+Use this workflow when scaffolding a new experiment under `packages/frontend/editor-ui/src/experiments/`.
+
+## Ask or infer
+
+1. Experiment folder name, for example `setupPanelV2`.
+2. Experiment constant name, for example `SETUP_PANEL_V2_EXPERIMENT`.
+3. Variant shape:
+   - simple `control/variant`, or
+   - multi-variant.
+4. Public API shape:
+   - default to a Pinia store,
+   - only use a composable when the experiment is genuinely tiny and stateless.
+5. Whether persisted UI state is needed.
+6. Whether optional `components/`, `data/`, `workflows/`, or host-surface wiring are in scope.
+
+## Always do
+
+1. Start in `packages/frontend/editor-ui/src/app/constants/experiments.ts`.
+2. Add the experiment constant.
+3. Add the experiment name to `EXPERIMENTS_TO_TRACK`.
+4. Create `packages/frontend/editor-ui/src/experiments/<name>/`.
+5. Pick one public API path:
+   - Store-backed by default: add a `STORES.EXPERIMENT_*` entry in `packages/frontend/@n8n/stores/src/constants.ts`, then create `stores/<name>.store.ts` and `stores/<name>.store.test.ts`.
+   - Tiny stateless composable only by exception: skip the `STORES.EXPERIMENT_*` entry and create a single composable such as `use<Name>Experiment.ts` with an adjacent test when needed.
+6. If the experiment needs persisted UI state or a shared mutable API, use the store path, not the composable path.
+
+## Enrollment standard
+
+- Use `isEnabled` for PostHog enrollment only.
+- For simple experiments, use `posthogStore.isVariantEnabled(EXPERIMENT.name, EXPERIMENT.variant)`.
+- For multi-variant experiments, expose `currentVariant` and derive booleans from it.
+- Keep display state separate with `shouldShow*`, `can*`, `hasDismissed*`, or `hasInteracted*`.
+
+Do not mix enrollment with:
+
+- `userIsTrialing`,
+- cloud-only checks,
+- selected-app checks,
+- workflow-count checks,
+- dismissal state.
+
+If the user wants those conditions, treat them as local display logic, not enrollment logic.
+
+## Persistence standard
+
+Use `packages/frontend/editor-ui/src/app/composables/useStorage.ts` for experiment-owned persisted UI state.
+
+Use it for:
+
+- dismissed state,
+- interaction state,
+- last-seen state.
+
+Do not use raw `localStorage` for new experiment-owned state unless the experiment must touch an existing non-experiment app key.
+
+## Telemetry standard
+
+- Keep `"User is part of experiment"` tracking centralized.
+- Scaffold only experiment-specific `track*` helpers such as `trackViewed`, `trackClicked`, `trackDismissed`, or `trackCompleted`.
+
+## Store scaffold
+
+Default to this store shape and adapt names as needed:
+
+```ts
+import { useTelemetry } from '@/app/composables/useTelemetry';
+import { useStorage } from '@/app/composables/useStorage';
+import { SETUP_PANEL_V2_EXPERIMENT } from '@/app/constants';
+import { usePostHog } from '@/app/stores/posthog.store';
+import { STORES } from '@n8n/stores';
+import { defineStore } from 'pinia';
+import { computed } from 'vue';
+
+const DISMISSED_KEY = 'N8N_SETUP_PANEL_V2_DISMISSED';
+
+export const useSetupPanelV2Store = defineStore(STORES.EXPERIMENT_SETUP_PANEL_V2, () => {
+	const posthogStore = usePostHog();
+	const telemetry = useTelemetry();
+	const dismissed = useStorage(DISMISSED_KEY);
+
+	const isEnabled = computed(() =>
+		posthogStore.isVariantEnabled(
+			SETUP_PANEL_V2_EXPERIMENT.name,
+			SETUP_PANEL_V2_EXPERIMENT.variant,
+		),
+	);
+	const isDismissed = computed(() => dismissed.value === 'true');
+	const shouldShowCallout = computed(() => isEnabled.value && !isDismissed.value);
+
+	function dismiss() {
+		dismissed.value = 'true';
+	}
+
+	function trackViewed() {
+		telemetry.track('Setup panel v2 viewed');
+	}
+
+	return {
+		isEnabled,
+		isDismissed,
+		shouldShowCallout,
+		dismiss,
+		trackViewed,
+	};
+});
+```
+
+## Test scaffold
+
+Default to one public API test next to the store. Use `stores/<name>.store.test.ts` as the standard location. Mirror the local style from:
+
+- `packages/frontend/editor-ui/src/experiments/credentialsAppSelection/stores/credentialsAppSelection.store.test.ts`
+- `packages/frontend/editor-ui/src/experiments/resourceCenter/stores/__tests__/resourceCenter.store.test.ts`
+
+Use `__tests__/` only when the surrounding experiment already follows that layout or when the local package pattern makes colocating the test awkward.
+
+The default assertions should cover:
+
+1. enrollment logic,
+2. persisted state when present,
+3. experiment-specific telemetry helpers when present.
+
+## Do not do by default
+
+- Do not wire routes, layouts, sidebars, or modals automatically.
+- Do not add empty `components/`, `data/`, or `workflows/` folders unless requested.
+- Do not add product gating on top of PostHog enrollment unless the user explicitly wants local display logic.
+- Do not scaffold participation tracking inside the experiment.
+
+## Output reminder
+
+At the end of the scaffold, explicitly tell the user what is still manual, for example:
+
+- host-surface wiring,
+- i18n keys,
+- route guards,
+- modal registration,
+- extra workflow payload files.
diff --git a/.code-health-baseline.json b/.code-health-baseline.json
index 62dabbf4cb7..0ea3900b19e 100644
--- a/.code-health-baseline.json
+++ b/.code-health-baseline.json
@@ -1,7 +1,7 @@
 {
 	"version": 1,
-	"generated": "2026-05-12T09:37:31.489Z",
-	"totalViolations": 82,
+	"generated": "2026-05-13T10:23:52.870Z",
+	"totalViolations": 87,
 	"violations": {
 		"packages/@n8n/ai-workflow-builder.ee/package.json": [
 			{
@@ -52,13 +52,25 @@
 		"packages/@n8n/nodes-langchain/package.json": [
 			{
 				"rule": "catalog-violations",
-				"line": 292,
+				"line": 266,
+				"message": "@n8n/typeorm@0.3.20-16 should use \"catalog:\" (exists in pnpm-workspace.yaml)",
+				"hash": "a7c1bca1c439"
+			},
+			{
+				"rule": "catalog-violations",
+				"line": 267,
+				"message": "mysql2@3.17.0 should use \"catalog:\" (exists in pnpm-workspace.yaml)",
+				"hash": "2d7d1b715d0c"
+			},
+			{
+				"rule": "catalog-violations",
+				"line": 293,
 				"message": "openai@^6.34.0 should use \"catalog:\" (exists in pnpm-workspace.yaml)",
 				"hash": "3c1f53f0afe3"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 299,
+				"line": 300,
 				"message": "tmp-promise appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "88d67e2ef747"
 			},
@@ -70,25 +82,25 @@
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 274,
+				"line": 275,
 				"message": "cheerio appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "8cd029bb871e"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 284,
+				"line": 285,
 				"message": "jsdom appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "26f20ebea4b1"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 289,
+				"line": 290,
 				"message": "mongodb appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "46cb48884e22"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 293,
+				"line": 294,
 				"message": "pdf-parse appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "0c7d44a9c2e4"
 			}
@@ -220,49 +232,49 @@
 		"packages/@n8n/instance-ai/package.json": [
 			{
 				"rule": "catalog-violations",
-				"line": 80,
+				"line": 81,
 				"message": "@ai-sdk/anthropic appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "5b2153508e47"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 86,
+				"line": 87,
 				"message": "@types/psl appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "56dabb51b433"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 56,
+				"line": 57,
 				"message": "@mozilla/readability appears in 5 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "8fa6b9a8fc91"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 64,
+				"line": 65,
 				"message": "csv-parse appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "8f082fc2e8b6"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 71,
+				"line": 72,
 				"message": "turndown appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "9a9d97065952"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 87,
+				"line": 88,
 				"message": "@types/turndown appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "12e346c47b39"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 50,
+				"line": 51,
 				"message": "@joplin/turndown-plugin-gfm appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "a3cf1504b5c2"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 68,
+				"line": 69,
 				"message": "pdf-parse appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "283fa9114c03"
 			}
@@ -290,61 +302,61 @@
 		"packages/nodes-base/package.json": [
 			{
 				"rule": "catalog-violations",
-				"line": 911,
+				"line": 913,
 				"message": "change-case appears in 5 packages with 3 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "2d1fab7a5b05"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 961,
+				"line": 963,
 				"message": "semver appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "2daf37aa14e4"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 966,
+				"line": 968,
 				"message": "tmp-promise appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "3f93c404ae9c"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 900,
+				"line": 902,
 				"message": "@mozilla/readability appears in 5 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "ca4ac788adc6"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 912,
+				"line": 914,
 				"message": "cheerio appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "1a1b5bbc50c9"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 915,
+				"line": 917,
 				"message": "csv-parse appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "781db4a1e068"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 917,
+				"line": 919,
 				"message": "eventsource appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "9795e6c6d9e9"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 930,
+				"line": 932,
 				"message": "jsdom appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "02341f2b5e3e"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 941,
+				"line": 943,
 				"message": "mongodb appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "f688907d087a"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 892,
+				"line": 894,
 				"message": "eslint-plugin-n8n-nodes-base appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "ac254baa61f9"
 			}
@@ -384,19 +396,19 @@
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 90,
+				"line": 91,
 				"message": "prettier appears in 3 packages with 3 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "9e9c7ec09a0b"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 92,
+				"line": 93,
 				"message": "semver appears in 4 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "d8c606e42c92"
 			},
 			{
 				"rule": "catalog-violations",
-				"line": 77,
+				"line": 78,
 				"message": "esprima-next appears in 3 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "62156c2613b2"
 			}
@@ -491,6 +503,14 @@
 				"hash": "733c3960022e"
 			}
 		],
+		"packages/@n8n/computer-use/package.json": [
+			{
+				"rule": "catalog-violations",
+				"line": 47,
+				"message": "eventsource appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
+				"hash": "f50c1eee2ed6"
+			}
+		],
 		"packages/workflow/package.json": [
 			{
 				"rule": "catalog-violations",
@@ -511,14 +531,6 @@
 				"hash": "b660317b5f6f"
 			}
 		],
-		"packages/@n8n/computer-use/package.json": [
-			{
-				"rule": "catalog-violations",
-				"line": 47,
-				"message": "eventsource appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
-				"hash": "f50c1eee2ed6"
-			}
-		],
 		"packages/@n8n/eslint-plugin-community-nodes/package.json": [
 			{
 				"rule": "catalog-violations",
@@ -540,6 +552,30 @@
 				"message": "stylelint appears in 2 packages with 2 different versions — add to pnpm-workspace.yaml catalog",
 				"hash": "955f3fe044c7"
 			}
+		],
+		"packages/@n8n/db/src/migrations/common/1783000000000-CreateAgentTables.ts": [
+			{
+				"rule": "migration-timestamp",
+				"line": 1,
+				"message": "1783000000000-CreateAgentTables.ts is prefixed with a future timestamp (1783000000000, ~50d ahead of now). Migration prefixes must be the exact Date.now() value at the time of creation — AI agents commonly fabricate future timestamps.",
+				"hash": "d81428d567aa"
+			}
+		],
+		"packages/@n8n/db/src/migrations/common/1783000000001-CreateAgentExecutionTables.ts": [
+			{
+				"rule": "migration-timestamp",
+				"line": 1,
+				"message": "1783000000001-CreateAgentExecutionTables.ts is prefixed with a future timestamp (1783000000001, ~50d ahead of now). Migration prefixes must be the exact Date.now() value at the time of creation — AI agents commonly fabricate future timestamps.",
+				"hash": "e33a8a794126"
+			}
+		],
+		"packages/@n8n/db/src/migrations/common/1784000000000-CreateAgentObservationTables.ts": [
+			{
+				"rule": "migration-timestamp",
+				"line": 1,
+				"message": "1784000000000-CreateAgentObservationTables.ts is prefixed with a future timestamp (1784000000000, ~61d ahead of now). Migration prefixes must be the exact Date.now() value at the time of creation — AI agents commonly fabricate future timestamps.",
+				"hash": "4bae5ef065ad"
+			}
 		]
 	}
 }
diff --git a/.github/workflows/ci-pr-quality.yml b/.github/workflows/ci-pr-quality.yml
index 33bad80fcd9..f13c783c43a 100644
--- a/.github/workflows/ci-pr-quality.yml
+++ b/.github/workflows/ci-pr-quality.yml
@@ -134,6 +134,7 @@ jobs:
               pnpm-workspace.yaml
               .code-health-baseline.json
               packages/testing/code-health/**
+              .github/workflows/**
 
   check-static-analysis:
     name: Static Analysis
diff --git a/packages/@n8n/api-types/src/index.ts b/packages/@n8n/api-types/src/index.ts
index 1f7aed31203..85e3aa56bd2 100644
--- a/packages/@n8n/api-types/src/index.ts
+++ b/packages/@n8n/api-types/src/index.ts
@@ -221,6 +221,7 @@ export {
 	type DataTableListSortBy,
 	dateTimeSchema,
 	dataTableColumnNameSchema,
+	dataTableIdSchema,
 } from './schemas/data-table.schema';
 
 export type {
@@ -439,6 +440,27 @@ export {
 	type StartTestRunPayload,
 } from './schemas/evaluations.schema';
 
+export {
+	EVAL_COLLECTIONS_FLAG,
+	evalCollectionVersionEntrySchema,
+	createEvaluationCollectionSchema,
+	CreateEvaluationCollectionDto,
+	updateEvaluationCollectionSchema,
+	UpdateEvaluationCollectionDto,
+	addRunToCollectionSchema,
+	AddRunToCollectionDto,
+	type EvalCollectionVersionEntry,
+	type CreateEvaluationCollectionPayload,
+	type UpdateEvaluationCollectionPayload,
+	type AddRunToCollectionPayload,
+	type EvalCollectionRunStatus,
+	type EvaluationCollectionRecord,
+	type EvaluationCollectionRunSummary,
+	type EvaluationCollectionDetail,
+	type EvalVersionEntry,
+	type EvalVersionsResponse,
+} from './schemas/eval-collections.schema';
+
 export { ALLOWED_DOMAINS, isAllowedDomain } from './utils/allowed-domains';
 
 export type { PublishTimelineEvent } from './schemas/workflow-publish-timeline.schema';
diff --git a/packages/@n8n/api-types/src/schemas/data-table.schema.ts b/packages/@n8n/api-types/src/schemas/data-table.schema.ts
index 00e281e21bc..c8c10c9d451 100644
--- a/packages/@n8n/api-types/src/schemas/data-table.schema.ts
+++ b/packages/@n8n/api-types/src/schemas/data-table.schema.ts
@@ -5,7 +5,10 @@ import type { ListDataTableQueryDto } from '../dto';
 export const insertRowReturnType = z.union([z.literal('all'), z.literal('count'), z.literal('id')]);
 
 export const dataTableNameSchema = z.string().trim().min(1).max(128);
-export const dataTableIdSchema = z.string().max(36);
+export const dataTableIdSchema = z
+	.string()
+	.max(36)
+	.regex(/^[a-zA-Z0-9]+$/);
 
 // Postgres does not allow leading numbers or -
 export const DATA_TABLE_COLUMN_REGEX = /^[a-zA-Z][a-zA-Z0-9_]*$/;
diff --git a/packages/@n8n/api-types/src/schemas/eval-collections.schema.ts b/packages/@n8n/api-types/src/schemas/eval-collections.schema.ts
new file mode 100644
index 00000000000..256b07eb817
--- /dev/null
+++ b/packages/@n8n/api-types/src/schemas/eval-collections.schema.ts
@@ -0,0 +1,112 @@
+import { z } from 'zod';
+
+import { Z } from '../zod-class';
+
+// Mirrors the `TestRunStatus` union in `@n8n/db`. Duplicated here so
+// `@n8n/api-types` does not need to depend on the db package.
+export type EvalCollectionRunStatus = 'new' | 'running' | 'completed' | 'error' | 'cancelled';
+
+// PostHog rollout flag id gating the eval-collections feature surface. All
+// new endpoints + frontend entry points consult this; flag-off cohort sees
+// the legacy single-run flow unchanged. Single source of truth shared
+// between FE and BE so the two cannot drift. Matches the spec verbatim —
+// the existing `080_eval_parallel_execution` flag follows a numeric-prefix
+// convention but the spec called for the literal id here.
+export const EVAL_COLLECTIONS_FLAG = 'eval_collections';
+
+// Per-version entry on a create-collection request. Either reference an
+// existing test run (`existingTestRunId`) to reuse it, or omit it and the
+// service will schedule a fresh run pinned to `workflowVersionId`. A null
+// `workflowVersionId` means "current draft" — the service snapshots a new
+// `WorkflowHistory` row at run start so the run stays comparable.
+export const evalCollectionVersionEntrySchema = z.object({
+	workflowVersionId: z.string().min(1).nullable(),
+	existingTestRunId: z.string().min(1).optional(),
+	label: z.string().min(1).max(128).optional(),
+});
+
+export type EvalCollectionVersionEntry = z.infer<typeof evalCollectionVersionEntrySchema>;
+
+const createEvaluationCollectionShape = {
+	name: z.string().min(1).max(128),
+	description: z.string().nullable().optional(),
+	evaluationConfigId: z.string().min(1),
+	versions: z.array(evalCollectionVersionEntrySchema).min(1),
+	concurrency: z.number().int().min(1).max(10).optional(),
+};
+
+export const createEvaluationCollectionSchema = z.object(createEvaluationCollectionShape);
+export type CreateEvaluationCollectionPayload = z.infer<typeof createEvaluationCollectionSchema>;
+
+export class CreateEvaluationCollectionDto extends Z.class(createEvaluationCollectionShape) {}
+
+const updateEvaluationCollectionShape = {
+	name: z.string().min(1).max(128).optional(),
+	description: z.string().nullable().optional(),
+};
+
+export const updateEvaluationCollectionSchema = z.object(updateEvaluationCollectionShape);
+export type UpdateEvaluationCollectionPayload = z.infer<typeof updateEvaluationCollectionSchema>;
+
+export class UpdateEvaluationCollectionDto extends Z.class(updateEvaluationCollectionShape) {}
+
+const addRunToCollectionShape = {
+	testRunId: z.string().min(1),
+};
+
+export const addRunToCollectionSchema = z.object(addRunToCollectionShape);
+export type AddRunToCollectionPayload = z.infer<typeof addRunToCollectionSchema>;
+
+export class AddRunToCollectionDto extends Z.class(addRunToCollectionShape) {}
+
+// Response shapes. These are not validated input — they describe what the
+// server returns. Keeping them as plain TypeScript types (not zod schemas)
+// avoids forcing the server to round-trip its own outputs through zod.
+
+export type EvaluationCollectionRecord = {
+	id: string;
+	name: string;
+	description: string | null;
+	workflowId: string;
+	evaluationConfigId: string;
+	createdById: string | null;
+	createdAt: string;
+	updatedAt: string;
+	runCount: number;
+};
+
+export type EvaluationCollectionRunSummary = {
+	testRunId: string;
+	workflowVersionId: string | null;
+	status: EvalCollectionRunStatus;
+	runAt: string | null;
+	completedAt: string | null;
+	avgScore: number | null;
+	metrics: Record<string, number> | null;
+};
+
+export type EvaluationCollectionDetail = EvaluationCollectionRecord & {
+	runs: EvaluationCollectionRunSummary[];
+};
+
+// Versions-picker endpoint response. The setup wizard renders one row per
+// item; `lastRun = null` means "no run yet · will run new" in the UI.
+export type EvalVersionEntry = {
+	workflowVersionId: string | null;
+	label: string;
+	sourceLabel: string;
+	isCurrent: boolean;
+	lastRun: {
+		testRunId: string;
+		runAt: string;
+		status: EvalCollectionRunStatus;
+		avgScore: number | null;
+		isBest: boolean;
+		isCritical: boolean;
+	} | null;
+};
+
+export type EvalVersionsResponse = {
+	evaluationConfigId: string;
+	versions: EvalVersionEntry[];
+};
diff --git a/packages/@n8n/db/src/entities/evaluation-collection.ee.ts b/packages/@n8n/db/src/entities/evaluation-collection.ee.ts
new file mode 100644
index 00000000000..32b0e7a1dff
--- /dev/null
+++ b/packages/@n8n/db/src/entities/evaluation-collection.ee.ts
@@ -0,0 +1,58 @@
+import { Column, Entity, Index, PrimaryColumn } from '@n8n/typeorm';
+import type { IDataObject } from 'n8n-workflow';
+
+import { JsonColumn, WithTimestamps } from './abstract-entity';
+
+/**
+ * A named, user-curated group of {@link TestRun}s sharing one
+ * {@link EvaluationConfig} (= one dataset + one set of metrics + one workflow),
+ * typically spread across multiple workflow versions. The collection is the
+ * unit of comparison in the eval compare view.
+ *
+ * Invariants enforced at the service layer:
+ *  - Every run in a collection has the same `evaluationConfigId`.
+ *  - Every run is on the same workflow as the collection.
+ *  - Runs typically differ by `workflowVersionId`.
+ *
+ * **TypeORM relations:** the `workflowId` and `evaluationConfigId` columns
+ * are FK columns *without* `@ManyToOne` decorators. Service code resolves
+ * the related entities through their own repositories. Declaring the
+ * relations on this entity would extend the TypeORM entity-relation type
+ * graph enough to trip TS2589 ("type instantiation excessively deep") in
+ * unrelated repositories that transitively reach `TestRun` →
+ * `EvaluationCollection` through `WorkflowEntity.testRuns` — e.g.
+ * `FolderRepository.upsert()` in `source-control-import.service.ee.ts`.
+ * The FK constraints are preserved by the migration's raw SQL; the
+ * decorators are purely TypeORM-side metadata.
+ */
+@Entity()
+export class EvaluationCollection extends WithTimestamps {
+	@PrimaryColumn({ type: 'varchar', length: 36 })
+	id: string;
+
+	@Column('varchar', { length: 128 })
+	name: string;
+
+	@Column('text', { nullable: true })
+	description: string | null;
+
+	@Index()
+	@Column('varchar', { length: 36 })
+	workflowId: string;
+
+	@Index()
+	@Column('varchar', { length: 36 })
+	evaluationConfigId: string;
+
+	@Column({ type: 'uuid', nullable: true })
+	createdById: string | null;
+
+	/**
+	 * Cached AI-generated insights for this collection. Lazily populated when
+	 * a user opens the compare view; re-generated when runs change. Shape
+	 * mirrors the `AiInsightsResponse` type produced by the insights agent —
+	 * stored loose here so PR 2 can iterate on the schema without a migration.
+	 */
+	@JsonColumn({ nullable: true })
+	insightsCache: IDataObject | null;
+}
diff --git a/packages/@n8n/db/src/entities/index.ts b/packages/@n8n/db/src/entities/index.ts
index 00f866dca10..ba3286c45b3 100644
--- a/packages/@n8n/db/src/entities/index.ts
+++ b/packages/@n8n/db/src/entities/index.ts
@@ -11,6 +11,7 @@ import {
 } from './credential-dependency-entity';
 import { CredentialsEntity } from './credentials-entity';
 import { DeploymentKey } from './deployment-key';
+import { EvaluationCollection } from './evaluation-collection.ee';
 import { EvaluationConfig } from './evaluation-config.ee';
 import { ExecutionAnnotation } from './execution-annotation.ee';
 import { ExecutionData } from './execution-data';
@@ -63,6 +64,7 @@ export {
 	CredentialDependency,
 	type CredentialDependencyType,
 	DeploymentKey,
+	EvaluationCollection,
 	EvaluationConfig,
 	Folder,
 	Project,
@@ -109,6 +111,7 @@ export const entities = {
 	CredentialsEntity,
 	CredentialDependency,
 	DeploymentKey,
+	EvaluationCollection,
 	EvaluationConfig,
 	Folder,
 	Project,
diff --git a/packages/@n8n/db/src/entities/test-run.ee.ts b/packages/@n8n/db/src/entities/test-run.ee.ts
index c415194f319..dfb5c249163 100644
--- a/packages/@n8n/db/src/entities/test-run.ee.ts
+++ b/packages/@n8n/db/src/entities/test-run.ee.ts
@@ -1,4 +1,4 @@
-import { Column, Entity, OneToMany, ManyToOne } from '@n8n/typeorm';
+import { Column, Entity, Index, OneToMany, ManyToOne } from '@n8n/typeorm';
 import type { IDataObject } from 'n8n-workflow';
 
 import { DateTimeColumn, JsonColumn, WithTimestampsAndStringId } from './abstract-entity';
@@ -63,6 +63,30 @@ export class TestRun extends WithTimestampsAndStringId {
 	@Column('boolean', { default: false })
 	cancelRequested: boolean;
 
+	@Column('varchar', { length: 36, nullable: true })
+	workflowVersionId: string | null;
+
+	// FK column only — no `@ManyToOne` decorator. Service code queries via
+	// `evaluationConfigId` and resolves the config through its own repository
+	// when needed. Declaring the relation on `TestRun` would extend the
+	// TypeORM entity-relation type graph enough to trip TS2589
+	// ("type instantiation excessively deep") in unrelated repositories that
+	// transitively reach `TestRun` through `WorkflowEntity.testRuns` — e.g.
+	// `FolderRepository.upsert()` in `source-control-import.service.ee.ts`.
+	// The FK constraint is preserved by the migration's raw SQL; the
+	// decorator is purely TypeORM-side metadata.
+	@Index()
+	@Column('varchar', { length: 36, nullable: true })
+	evaluationConfigId: string | null;
+
+	@JsonColumn({ nullable: true })
+	evaluationConfigSnapshot: IDataObject | null;
+
+	// FK column only — see `evaluationConfigId` comment above for rationale.
+	@Index()
+	@Column('varchar', { length: 36, nullable: true })
+	collectionId: string | null;
+
 	/**
 	 * Calculated property to determine the final result of the test run
 	 * depending on the statuses of test case executions
diff --git a/packages/@n8n/db/src/migrations/common/1778496086558-CreateEvaluationCollection.ts b/packages/@n8n/db/src/migrations/common/1778496086558-CreateEvaluationCollection.ts
new file mode 100644
index 00000000000..191d42369dd
--- /dev/null
+++ b/packages/@n8n/db/src/migrations/common/1778496086558-CreateEvaluationCollection.ts
@@ -0,0 +1,85 @@
+import type { MigrationContext, ReversibleMigration } from '../migration-types';
+
+const EVALUATION_COLLECTION_TABLE = 'evaluation_collection';
+const TEST_RUN_TABLE = 'test_run';
+const EVALUATION_CONFIG_TABLE = 'evaluation_config';
+const WORKFLOW_TABLE = 'workflow_entity';
+const USER_TABLE = 'user';
+const FK_TEST_RUN_COLLECTION = 'FK_test_run_collection_id';
+
+export class CreateEvaluationCollection1778496086558 implements ReversibleMigration {
+	async up({
+		schemaBuilder: { createTable, addColumns, addForeignKey, createIndex, column },
+		queryRunner,
+		isSqlite,
+	}: MigrationContext) {
+		await createTable(EVALUATION_COLLECTION_TABLE)
+			.withColumns(
+				column('id').varchar(36).primary.notNull,
+				column('name').varchar(128).notNull,
+				column('description').text,
+				column('workflowId').varchar(36).notNull,
+				column('evaluationConfigId').varchar(36).notNull,
+				column('createdById').uuid,
+				column('insightsCache').json,
+			)
+			.withForeignKey('workflowId', {
+				tableName: WORKFLOW_TABLE,
+				columnName: 'id',
+				onDelete: 'CASCADE',
+			})
+			.withForeignKey('evaluationConfigId', {
+				tableName: EVALUATION_CONFIG_TABLE,
+				columnName: 'id',
+				onDelete: 'CASCADE',
+			})
+			.withForeignKey('createdById', {
+				tableName: USER_TABLE,
+				columnName: 'id',
+				onDelete: 'SET NULL',
+			})
+			.withIndexOn('workflowId')
+			.withIndexOn('evaluationConfigId').withTimestamps;
+
+		// On SQLite, `addColumns` and `addForeignKey` both trigger a full
+		// table rebuild via TypeORM's cached `Table` metadata. The prior
+		// migration `1778100002000-AddEvaluationConfigColumnsToTestRun`
+		// added the `evaluationConfigSnapshot` column on SQLite via raw
+		// `ALTER TABLE ADD COLUMN`, which TypeORM doesn't observe — so its
+		// cached metadata is stale by the time this migration runs. Without
+		// this refresh, the next rebuild silently drops the column and
+		// every subsequent `TestRun` insert fails with
+		// "SQLITE_ERROR: table test_run has no column named
+		// evaluationConfigSnapshot". `queryRunner.getTable()` reloads from
+		// PRAGMA table_info so the rebuild reads the actual current schema.
+		if (isSqlite) {
+			await queryRunner.getTable(TEST_RUN_TABLE);
+		}
+
+		await addColumns(TEST_RUN_TABLE, [column('collectionId').varchar(36)]);
+
+		await addForeignKey(
+			TEST_RUN_TABLE,
+			'collectionId',
+			[EVALUATION_COLLECTION_TABLE, 'id'],
+			FK_TEST_RUN_COLLECTION,
+			'SET NULL',
+		);
+
+		await createIndex(TEST_RUN_TABLE, ['collectionId']);
+	}
+
+	async down({
+		schemaBuilder: { dropColumns, dropTable, dropForeignKey, dropIndex },
+	}: MigrationContext) {
+		await dropIndex(TEST_RUN_TABLE, ['collectionId']);
+		await dropForeignKey(
+			TEST_RUN_TABLE,
+			'collectionId',
+			[EVALUATION_COLLECTION_TABLE, 'id'],
+			FK_TEST_RUN_COLLECTION,
+		);
+		await dropColumns(TEST_RUN_TABLE, ['collectionId']);
+		await dropTable(EVALUATION_COLLECTION_TABLE);
+	}
+}
diff --git a/packages/@n8n/db/src/migrations/postgresdb/index.ts b/packages/@n8n/db/src/migrations/postgresdb/index.ts
index 74776d778a6..b72e950247e 100644
--- a/packages/@n8n/db/src/migrations/postgresdb/index.ts
+++ b/packages/@n8n/db/src/migrations/postgresdb/index.ts
@@ -172,6 +172,7 @@ import { AddExecutionDeduplicationKey1778000000000 } from '../common/17780000000
 import { CreateEvaluationConfig1778100000000 } from '../common/1778100000000-CreateEvaluationConfig';
 import { AddWorkflowVersionToTestRun1778100001000 } from '../common/1778100001000-AddWorkflowVersionToTestRun';
 import { AddEvaluationConfigColumnsToTestRun1778100002000 } from '../common/1778100002000-AddEvaluationConfigColumnsToTestRun';
+import { CreateEvaluationCollection1778496086558 } from '../common/1778496086558-CreateEvaluationCollection';
 import { CreateAgentTables1783000000000 } from '../common/1783000000000-CreateAgentTables';
 import { CreateAgentExecutionTables1783000000001 } from '../common/1783000000001-CreateAgentExecutionTables';
 import { CreateAgentObservationTables1784000000000 } from '../common/1784000000000-CreateAgentObservationTables';
@@ -352,6 +353,7 @@ export const postgresMigrations: Migration[] = [
 	CreateEvaluationConfig1778100000000,
 	AddWorkflowVersionToTestRun1778100001000,
 	AddEvaluationConfigColumnsToTestRun1778100002000,
+	CreateEvaluationCollection1778496086558,
 	CreateAgentTables1783000000000,
 	CreateAgentExecutionTables1783000000001,
 	CreateAgentObservationTables1784000000000,
diff --git a/packages/@n8n/db/src/migrations/sqlite/index.ts b/packages/@n8n/db/src/migrations/sqlite/index.ts
index 24fe84335ce..26347676a6a 100644
--- a/packages/@n8n/db/src/migrations/sqlite/index.ts
+++ b/packages/@n8n/db/src/migrations/sqlite/index.ts
@@ -165,6 +165,7 @@ import { AddExecutionDeduplicationKey1778000000000 } from '../common/17780000000
 import { CreateEvaluationConfig1778100000000 } from '../common/1778100000000-CreateEvaluationConfig';
 import { AddWorkflowVersionToTestRun1778100001000 } from '../common/1778100001000-AddWorkflowVersionToTestRun';
 import { AddEvaluationConfigColumnsToTestRun1778100002000 } from '../common/1778100002000-AddEvaluationConfigColumnsToTestRun';
+import { CreateEvaluationCollection1778496086558 } from '../common/1778496086558-CreateEvaluationCollection';
 import { CreateAgentTables1783000000000 } from '../common/1783000000000-CreateAgentTables';
 import { CreateAgentExecutionTables1783000000001 } from '../common/1783000000001-CreateAgentExecutionTables';
 import { CreateAgentObservationTables1784000000000 } from '../common/1784000000000-CreateAgentObservationTables';
@@ -338,6 +339,7 @@ const sqliteMigrations: Migration[] = [
 	CreateEvaluationConfig1778100000000,
 	AddWorkflowVersionToTestRun1778100001000,
 	AddEvaluationConfigColumnsToTestRun1778100002000,
+	CreateEvaluationCollection1778496086558,
 	CreateAgentTables1783000000000,
 	CreateAgentExecutionTables1783000000001,
 	CreateAgentObservationTables1784000000000,
diff --git a/packages/@n8n/db/src/repositories/__tests__/evaluation-collection.repository.test.ts b/packages/@n8n/db/src/repositories/__tests__/evaluation-collection.repository.test.ts
new file mode 100644
index 00000000000..831300a9a2b
--- /dev/null
+++ b/packages/@n8n/db/src/repositories/__tests__/evaluation-collection.repository.test.ts
@@ -0,0 +1,237 @@
+import { Container } from '@n8n/di';
+
+import { EvaluationCollection } from '../../entities/evaluation-collection.ee';
+import { TestRun } from '../../entities/test-run.ee';
+import { mockEntityManager } from '../../utils/test-utils/mock-entity-manager';
+import { EvaluationCollectionRepository } from '../evaluation-collection.repository';
+
+describe('EvaluationCollectionRepository', () => {
+	const entityManager = mockEntityManager(EvaluationCollection);
+	const repo = Container.get(EvaluationCollectionRepository);
+
+	beforeEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('createCollection', () => {
+		it('persists the collection with insightsCache initialised to null', async () => {
+			(entityManager.create as jest.Mock).mockImplementation(
+				(_target: unknown, entityLike: unknown) => entityLike as EvaluationCollection,
+			);
+			entityManager.save.mockImplementationOnce(async (_target, entity) => entity);
+
+			await repo.createCollection({
+				id: 'col-1',
+				name: 'C',
+				description: null,
+				workflowId: 'wf-1',
+				evaluationConfigId: 'cfg-1',
+				createdById: 'user-1',
+			});
+
+			const savedEntity = entityManager.save.mock.calls[0]?.[1];
+			expect(savedEntity).toMatchObject({
+				id: 'col-1',
+				name: 'C',
+				description: null,
+				workflowId: 'wf-1',
+				evaluationConfigId: 'cfg-1',
+				createdById: 'user-1',
+				insightsCache: null,
+			});
+		});
+	});
+
+	describe('findByIdAndWorkflowId', () => {
+		it('scopes the lookup to the route workflowId so foreign-workflow ids 404 the same as missing ids', async () => {
+			entityManager.findOne.mockResolvedValueOnce(null);
+
+			const result = await repo.findByIdAndWorkflowId('col-x', 'wf-1');
+
+			expect(result).toBeNull();
+			const callArgs = entityManager.findOne.mock.calls[0];
+			expect(callArgs?.[1]).toEqual({ where: { id: 'col-x', workflowId: 'wf-1' } });
+		});
+	});
+
+	describe('listByWorkflowId', () => {
+		it('joins runCount onto each collection with one aggregate query', async () => {
+			const collections = [
+				{ id: 'col-a', workflowId: 'wf-1', createdAt: new Date() },
+				{ id: 'col-b', workflowId: 'wf-1', createdAt: new Date() },
+			] as EvaluationCollection[];
+			entityManager.find.mockResolvedValueOnce(collections);
+			const qb = {
+				select: jest.fn().mockReturnThis(),
+				addSelect: jest.fn().mockReturnThis(),
+				where: jest.fn().mockReturnThis(),
+				groupBy: jest.fn().mockReturnThis(),
+				getRawMany: jest.fn().mockResolvedValueOnce([
+					{ collectionId: 'col-a', count: '3' },
+					{ collectionId: 'col-b', count: '0' },
+				]),
+			};
+			entityManager.createQueryBuilder.mockReturnValueOnce(qb as never);
+
+			const result = await repo.listByWorkflowId('wf-1');
+
+			expect(entityManager.createQueryBuilder).toHaveBeenCalledTimes(1);
+			expect(result.map((c) => c.runCount)).toEqual([3, 0]);
+		});
+
+		it('returns an empty array without an aggregate query when no collections exist', async () => {
+			entityManager.find.mockResolvedValueOnce([]);
+
+			const result = await repo.listByWorkflowId('wf-1');
+
+			expect(result).toEqual([]);
+			expect(entityManager.createQueryBuilder).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('addRunsToCollection', () => {
+		it('updates TestRun.collectionId in bulk by id', async () => {
+			entityManager.update.mockResolvedValueOnce({ affected: 2, generatedMaps: [], raw: [] });
+
+			await repo.addRunsToCollection('col-1', ['tr-a', 'tr-b']);
+
+			const callArgs = entityManager.update.mock.calls[0];
+			expect(callArgs?.[0]).toBe(TestRun);
+			expect(callArgs?.[2]).toEqual({ collectionId: 'col-1' });
+		});
+
+		it('is a no-op when given an empty id list', async () => {
+			await repo.addRunsToCollection('col-1', []);
+			expect(entityManager.update).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('removeRunFromCollection', () => {
+		it('only unlinks runs that are actually in the named collection', async () => {
+			entityManager.update.mockResolvedValueOnce({ affected: 1, generatedMaps: [], raw: [] });
+
+			const affected = await repo.removeRunFromCollection('col-1', 'tr-a');
+
+			expect(affected).toBe(1);
+			const callArgs = entityManager.update.mock.calls[0];
+			expect(callArgs?.[1]).toEqual({ id: 'tr-a', collectionId: 'col-1' });
+			expect(callArgs?.[2]).toEqual({ collectionId: null });
+		});
+
+		it('returns 0 when the run is not part of the collection', async () => {
+			entityManager.update.mockResolvedValueOnce({ affected: 0, generatedMaps: [], raw: [] });
+
+			expect(await repo.removeRunFromCollection('col-1', 'tr-missing')).toBe(0);
+		});
+	});
+
+	describe('deleteByIdAndWorkflowId', () => {
+		it('counts runs before delete so callers can report runs_unlinked for telemetry', async () => {
+			entityManager.findOne.mockResolvedValueOnce({ id: 'col-1' } as EvaluationCollection);
+			entityManager.count.mockResolvedValueOnce(4);
+			entityManager.delete.mockResolvedValueOnce({ affected: 1, raw: [] });
+
+			const result = await repo.deleteByIdAndWorkflowId('col-1', 'wf-1');
+
+			expect(result).toEqual({ deleted: true, runsUnlinked: 4 });
+		});
+
+		it('returns { deleted: false } without touching delete when the collection does not exist', async () => {
+			entityManager.findOne.mockResolvedValueOnce(null);
+
+			const result = await repo.deleteByIdAndWorkflowId('col-missing', 'wf-1');
+
+			expect(result).toEqual({ deleted: false, runsUnlinked: 0 });
+			expect(entityManager.delete).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('updateInsightsCache', () => {
+		it('updates the insightsCache JSON column on the row', async () => {
+			entityManager.update.mockResolvedValueOnce({ affected: 1, generatedMaps: [], raw: [] });
+
+			await repo.updateInsightsCache('col-1', { winner: { versionLabel: 'A' } } as never);
+
+			const callArgs = entityManager.update.mock.calls[0];
+			expect(callArgs?.[1]).toBe('col-1');
+			expect(callArgs?.[2]).toEqual({ insightsCache: { winner: { versionLabel: 'A' } } });
+		});
+
+		it('accepts null to clear the cache', async () => {
+			entityManager.update.mockResolvedValueOnce({ affected: 1, generatedMaps: [], raw: [] });
+
+			await repo.updateInsightsCache('col-1', null);
+
+			const callArgs = entityManager.update.mock.calls[0];
+			expect(callArgs?.[2]).toEqual({ insightsCache: null });
+		});
+	});
+
+	describe('updateMeta', () => {
+		it('returns null without writing when the collection does not exist', async () => {
+			entityManager.findOne.mockResolvedValueOnce(null);
+
+			const result = await repo.updateMeta('col-x', 'wf-1', { name: 'New' });
+
+			expect(result).toBeNull();
+			expect(entityManager.save).not.toHaveBeenCalled();
+		});
+
+		it('merges name + description onto the existing entity', async () => {
+			const existing = {
+				id: 'col-1',
+				name: 'Old',
+				description: 'old desc',
+				workflowId: 'wf-1',
+			} as EvaluationCollection;
+			entityManager.findOne.mockResolvedValueOnce(existing);
+			(entityManager.create as jest.Mock).mockImplementation(
+				(_target: unknown, entityLike: unknown) => entityLike as EvaluationCollection,
+			);
+			entityManager.save.mockImplementationOnce(async (_target, entity) => entity);
+
+			await repo.updateMeta('col-1', 'wf-1', { name: 'New', description: null });
+
+			const savedEntity = entityManager.save.mock.calls[0]?.[1];
+			expect(savedEntity).toMatchObject({
+				id: 'col-1',
+				name: 'New',
+				description: null,
+			});
+		});
+
+		it('preserves description when only name is provided', async () => {
+			const existing = {
+				id: 'col-1',
+				name: 'Old',
+				description: 'old desc',
+				workflowId: 'wf-1',
+			} as EvaluationCollection;
+			entityManager.findOne.mockResolvedValueOnce(existing);
+			entityManager.save.mockImplementationOnce(async (_target, entity) => entity);
+
+			await repo.updateMeta('col-1', 'wf-1', { name: 'New' });
+
+			const savedEntity = entityManager.save.mock.calls[0]?.[1] as EvaluationCollection;
+			expect(savedEntity.name).toBe('New');
+			expect(savedEntity.description).toBe('old desc');
+		});
+
+		it('preserves existing fields when payload props are undefined', async () => {
+			const existing = {
+				id: 'col-1',
+				name: 'Old',
+				description: 'old desc',
+				workflowId: 'wf-1',
+			} as EvaluationCollection;
+			entityManager.findOne.mockResolvedValueOnce(existing);
+			entityManager.save.mockImplementationOnce(async (_target, entity) => entity);
+
+			await repo.updateMeta('col-1', 'wf-1', { name: undefined, description: undefined });
+
+			const savedEntity = entityManager.save.mock.calls[0]?.[1] as EvaluationCollection;
+			expect(savedEntity.name).toBe('Old');
+			expect(savedEntity.description).toBe('old desc');
+		});
+	});
+});
diff --git a/packages/@n8n/db/src/repositories/evaluation-collection.repository.ts b/packages/@n8n/db/src/repositories/evaluation-collection.repository.ts
new file mode 100644
index 00000000000..25282876c3e
--- /dev/null
+++ b/packages/@n8n/db/src/repositories/evaluation-collection.repository.ts
@@ -0,0 +1,156 @@
+import { Service } from '@n8n/di';
+import { DataSource, In, Repository } from '@n8n/typeorm';
+import type { IDataObject } from 'n8n-workflow';
+
+import { EvaluationCollection } from '../entities/evaluation-collection.ee';
+import { TestRun } from '../entities/test-run.ee';
+
+export type EvaluationCollectionListItem = {
+	id: EvaluationCollection['id'];
+	name: EvaluationCollection['name'];
+	description: EvaluationCollection['description'];
+	workflowId: EvaluationCollection['workflowId'];
+	evaluationConfigId: EvaluationCollection['evaluationConfigId'];
+	createdById: EvaluationCollection['createdById'];
+	insightsCache: EvaluationCollection['insightsCache'];
+	createdAt: EvaluationCollection['createdAt'];
+	updatedAt: EvaluationCollection['updatedAt'];
+	runCount: number;
+};
+
+@Service()
+export class EvaluationCollectionRepository extends Repository<EvaluationCollection> {
+	constructor(dataSource: DataSource) {
+		super(EvaluationCollection, dataSource.manager);
+	}
+
+	async createCollection(input: {
+		id: string;
+		name: string;
+		description: string | null;
+		workflowId: string;
+		evaluationConfigId: string;
+		createdById: string | null;
+	}): Promise<EvaluationCollection> {
+		const entity = this.create({
+			id: input.id,
+			name: input.name,
+			description: input.description,
+			workflowId: input.workflowId,
+			evaluationConfigId: input.evaluationConfigId,
+			createdById: input.createdById,
+			insightsCache: null,
+		});
+		return await this.save(entity);
+	}
+
+	async findByIdAndWorkflowId(
+		id: string,
+		workflowId: string,
+	): Promise<EvaluationCollection | null> {
+		return await this.findOne({ where: { id, workflowId } });
+	}
+
+	/**
+	 * Returns collections for a workflow with `runCount` populated. The list
+	 * page uses this — it does not need the full run rows, just the count and
+	 * the collection's own fields.
+	 */
+	async listByWorkflowId(workflowId: string): Promise<EvaluationCollectionListItem[]> {
+		const collections = await this.find({
+			where: { workflowId },
+			order: { createdAt: 'DESC' },
+		});
+
+		if (collections.length === 0) return [];
+
+		const runCounts = await this.manager
+			.createQueryBuilder(TestRun, 'tr')
+			.select('tr.collectionId', 'collectionId')
+			.addSelect('COUNT(tr.id)', 'count')
+			.where('tr.collectionId IN (:...ids)', { ids: collections.map((c) => c.id) })
+			.groupBy('tr.collectionId')
+			.getRawMany<{ collectionId: string; count: string }>();
+
+		const countByCollectionId = new Map(
+			runCounts.map(({ collectionId, count }) => [collectionId, Number(count)]),
+		);
+
+		return collections.map((collection) => ({
+			...collection,
+			runCount: countByCollectionId.get(collection.id) ?? 0,
+		}));
+	}
+
+	/**
+	 * Returns the collection plus its runs ordered by createdAt ascending so
+	 * the compare view can render versions left-to-right by run order.
+	 */
+	async getDetailByIdAndWorkflowId(
+		id: string,
+		workflowId: string,
+	): Promise<{ collection: EvaluationCollection; runs: TestRun[] } | null> {
+		const collection = await this.findOne({ where: { id, workflowId } });
+		if (!collection) return null;
+
+		const runs = await this.manager.find(TestRun, {
+			where: { collectionId: id },
+			order: { createdAt: 'ASC' },
+		});
+
+		return { collection, runs };
+	}
+
+	async addRunsToCollection(collectionId: string, testRunIds: string[]): Promise<void> {
+		if (testRunIds.length === 0) return;
+		await this.manager.update(TestRun, { id: In(testRunIds) }, { collectionId });
+	}
+
+	async removeRunFromCollection(collectionId: string, testRunId: string): Promise<number> {
+		const result = await this.manager.update(
+			TestRun,
+			{ id: testRunId, collectionId },
+			{ collectionId: null },
+		);
+		return result.affected ?? 0;
+	}
+
+	/**
+	 * Returns how many runs were unlinked (set to `collectionId = null`) by
+	 * the delete. Callers feed this into the `runs_unlinked` telemetry field.
+	 *
+	 * The FK on `test_run.collectionId` is `SET NULL`, so we'd technically
+	 * get the unlink for free — but counting runs first lets the caller
+	 * surface the number in the response and telemetry without an extra
+	 * round-trip.
+	 */
+	async deleteByIdAndWorkflowId(
+		id: string,
+		workflowId: string,
+	): Promise<{ deleted: boolean; runsUnlinked: number }> {
+		const collection = await this.findOne({ where: { id, workflowId } });
+		if (!collection) return { deleted: false, runsUnlinked: 0 };
+
+		const runsUnlinked = await this.manager.count(TestRun, { where: { collectionId: id } });
+
+		await this.delete({ id });
+
+		return { deleted: true, runsUnlinked };
+	}
+
+	async updateInsightsCache(id: string, insights: IDataObject | null): Promise<void> {
+		await this.update(id, { insightsCache: insights });
+	}
+
+	async updateMeta(
+		id: string,
+		workflowId: string,
+		payload: { name?: string; description?: string | null },
+	): Promise<EvaluationCollection | null> {
+		const existing = await this.findByIdAndWorkflowId(id, workflowId);
+		if (!existing) return null;
+		if (payload.name !== undefined) existing.name = payload.name;
+		if (payload.description !== undefined) existing.description = payload.description;
+		return await this.save(existing);
+	}
+}
diff --git a/packages/@n8n/db/src/repositories/index.ts b/packages/@n8n/db/src/repositories/index.ts
index e6d80503d88..c17f877d18b 100644
--- a/packages/@n8n/db/src/repositories/index.ts
+++ b/packages/@n8n/db/src/repositories/index.ts
@@ -13,6 +13,10 @@ export {
 	type DeploymentKeySortDirection,
 	type ListDeploymentKeysOptions,
 } from './deployment-key.repository';
+export {
+	EvaluationCollectionRepository,
+	type EvaluationCollectionListItem,
+} from './evaluation-collection.repository';
 export { EvaluationConfigRepository } from './evaluation-config.repository';
 export { ExecutionAnnotationRepository } from './execution-annotation.repository';
 export { ExecutionDataRepository } from './execution-data.repository';
diff --git a/packages/@n8n/db/src/repositories/test-run.repository.ee.ts b/packages/@n8n/db/src/repositories/test-run.repository.ee.ts
index 56cb27d82b7..4785f93bb0f 100644
--- a/packages/@n8n/db/src/repositories/test-run.repository.ee.ts
+++ b/packages/@n8n/db/src/repositories/test-run.repository.ee.ts
@@ -22,12 +22,24 @@ export class TestRunRepository extends Repository<TestRun> {
 		super(TestRun, dataSource.manager);
 	}
 
-	async createTestRun(workflowId: string): Promise<TestRun> {
+	async createTestRun(
+		workflowId: string,
+		attrs?: {
+			collectionId?: string | null;
+			workflowVersionId?: string | null;
+			evaluationConfigId?: string | null;
+			evaluationConfigSnapshot?: IDataObject | null;
+		},
+	): Promise<TestRun> {
 		const testRun = this.create({
 			status: 'new',
 			workflow: {
 				id: workflowId,
 			},
+			collectionId: attrs?.collectionId ?? null,
+			workflowVersionId: attrs?.workflowVersionId ?? null,
+			evaluationConfigId: attrs?.evaluationConfigId ?? null,
+			evaluationConfigSnapshot: attrs?.evaluationConfigSnapshot ?? null,
 		});
 
 		return await this.save(testRun);
diff --git a/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.test.ts b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.test.ts
new file mode 100644
index 00000000000..55ad7fe7a3d
--- /dev/null
+++ b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.test.ts
@@ -0,0 +1,139 @@
+import { httpGenericAuthTypeMatchesPrompt } from './http-generic-auth-type-matches-prompt';
+import type { WorkflowResponse } from '../../clients/n8n-client';
+
+function workflowWithHttpRequest(parameters: Record<string, unknown>): WorkflowResponse {
+	return {
+		id: 'wf-1',
+		name: 'HTTP auth test',
+		active: false,
+		nodes: [
+			{
+				name: 'Manual Trigger',
+				type: 'n8n-nodes-base.manualTrigger',
+				parameters: {},
+			},
+			{
+				name: 'HTTP Request',
+				type: 'n8n-nodes-base.httpRequest',
+				parameters,
+			},
+		],
+		connections: {
+			'Manual Trigger': {
+				main: [[{ node: 'HTTP Request', type: 'main', index: 0 }]],
+			},
+		},
+	};
+}
+
+describe('httpGenericAuthTypeMatchesPrompt', () => {
+	it('fails when prompt asks for Bearer but builder picks httpHeaderAuth', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'genericCredentialType',
+			genericAuthType: 'httpHeaderAuth',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Call the GitHub API using a Bearer token',
+		});
+
+		expect(result.pass).toBe(false);
+		expect(result.comment).toContain('HTTP Request');
+		expect(result.comment).toContain('httpBearerAuth');
+	});
+
+	it('fails when prompt mentions Authorization: Bearer header explicitly', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'genericCredentialType',
+			genericAuthType: 'httpHeaderAuth',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Send a request with Authorization: Bearer <token>',
+		});
+
+		expect(result.pass).toBe(false);
+	});
+
+	it('passes when builder picks httpBearerAuth for a Bearer prompt', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'genericCredentialType',
+			genericAuthType: 'httpBearerAuth',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Call the GitHub API using a Bearer token',
+		});
+
+		expect(result).toEqual({ pass: true });
+	});
+
+	it('passes when prompt specifies a custom header name and builder picks httpHeaderAuth', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'genericCredentialType',
+			genericAuthType: 'httpHeaderAuth',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Call the Algolia API with an X-API-Key header',
+		});
+
+		expect(result).toEqual({ pass: true });
+	});
+
+	it('passes when the prompt has no auth signal at all', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'genericCredentialType',
+			genericAuthType: 'httpHeaderAuth',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Fetch data from a public endpoint',
+		});
+
+		expect(result).toEqual({ pass: true });
+	});
+
+	it('ignores HTTP Request nodes that do not use generic credential type', async () => {
+		const workflow = workflowWithHttpRequest({
+			authentication: 'predefinedCredentialType',
+			nodeCredentialType: 'githubApi',
+		});
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Call the GitHub API using a Bearer token',
+		});
+
+		expect(result).toEqual({ pass: true });
+	});
+
+	it('ignores non-HTTP-Request nodes', async () => {
+		const workflow: WorkflowResponse = {
+			id: 'wf-2',
+			name: 'Slack only',
+			active: false,
+			nodes: [
+				{
+					name: 'Manual Trigger',
+					type: 'n8n-nodes-base.manualTrigger',
+					parameters: {},
+				},
+				{
+					name: 'Slack',
+					type: 'n8n-nodes-base.slack',
+					parameters: {
+						authentication: 'genericCredentialType',
+						genericAuthType: 'httpHeaderAuth',
+					},
+				},
+			],
+			connections: {},
+		};
+
+		const result = await httpGenericAuthTypeMatchesPrompt.run(workflow, {
+			prompt: 'Send a Bearer-authenticated message',
+		});
+
+		expect(result).toEqual({ pass: true });
+	});
+});
diff --git a/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.ts b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.ts
new file mode 100644
index 00000000000..fd7fac4f06f
--- /dev/null
+++ b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/http-generic-auth-type-matches-prompt.ts
@@ -0,0 +1,68 @@
+import type { WorkflowNodeResponse } from '../../clients/n8n-client';
+import type { BinaryCheck } from '../types';
+
+const HTTP_REQUEST_TYPE = 'n8n-nodes-base.httpRequest';
+
+const BEARER_PROMPT_PATTERNS = [
+	/\bbearer\s+(?:token|auth(?:entication)?)\b/i,
+	/\bauthorization\s*:\s*bearer\b/i,
+	/\b(?:use|with|via|using)\s+(?:a\s+|my\s+)?bearer\b/i,
+];
+
+const CUSTOM_HEADER_NAME_PATTERNS = [
+	/\bx-[a-z][a-z0-9-]*\b/i,
+	/\bheader\s+(?:named|called)\s+["'`]?[a-z][\w-]*["'`]?/i,
+	/\bcustom\s+header\b/i,
+	/\bheader\s+name\b/i,
+	/\bapikey\s+header\b/i,
+];
+
+function isHttpRequestWithGenericAuth(node: WorkflowNodeResponse): boolean {
+	return (
+		node.type === HTTP_REQUEST_TYPE && node.parameters?.authentication === 'genericCredentialType'
+	);
+}
+
+function getGenericAuthType(node: WorkflowNodeResponse): string {
+	const value = node.parameters?.genericAuthType;
+	return typeof value === 'string' ? value : '';
+}
+
+function promptAsksForBearer(prompt: string): boolean {
+	return BEARER_PROMPT_PATTERNS.some((p) => p.test(prompt));
+}
+
+function promptSpecifiesCustomHeaderName(prompt: string): boolean {
+	return CUSTOM_HEADER_NAME_PATTERNS.some((p) => p.test(prompt));
+}
+
+export const httpGenericAuthTypeMatchesPrompt: BinaryCheck = {
+	name: 'http_generic_auth_type_matches_prompt',
+	description:
+		'HTTP Request nodes pick a genericAuthType consistent with the prompt — prefer httpBearerAuth for Authorization: Bearer flows; reserve httpHeaderAuth for custom header names',
+	kind: 'deterministic',
+	run(workflow, ctx) {
+		const issues: string[] = [];
+
+		for (const node of workflow.nodes ?? []) {
+			if (!isHttpRequestWithGenericAuth(node)) continue;
+
+			const genericAuthType = getGenericAuthType(node);
+			if (genericAuthType !== 'httpHeaderAuth') continue;
+
+			const bearerIntent = promptAsksForBearer(ctx.prompt);
+			const customHeaderIntent = promptSpecifiesCustomHeaderName(ctx.prompt);
+
+			if (bearerIntent && !customHeaderIntent) {
+				issues.push(
+					`"${node.name}" uses httpHeaderAuth but the prompt asks for Bearer auth — should be httpBearerAuth`,
+				);
+			}
+		}
+
+		return {
+			pass: issues.length === 0,
+			...(issues.length > 0 ? { comment: issues.join('; ') } : {}),
+		};
+	},
+};
diff --git a/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/index.ts b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/index.ts
index 8a5bfc9c17c..a03943c9ff2 100644
--- a/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/index.ts
+++ b/packages/@n8n/instance-ai/evaluations/binaryChecks/checks/index.ts
@@ -14,6 +14,7 @@ import { handlesMultipleItems } from './handles-multiple-items';
 import { hasNodes } from './has-nodes';
 import { hasStartNode } from './has-start-node';
 import { hasTrigger } from './has-trigger';
+import { httpGenericAuthTypeMatchesPrompt } from './http-generic-auth-type-matches-prompt';
 import { inboundTriggerAuthDefaults } from './inbound-trigger-auth-defaults';
 import { memoryProperlyConnected } from './memory-properly-connected';
 import { memorySessionKeyExpression } from './memory-session-key-expression';
@@ -50,6 +51,7 @@ export const DETERMINISTIC_CHECKS: BinaryCheck[] = [
 	toolsHaveParameters,
 	noUnreachableNodes,
 	inboundTriggerAuthDefaults,
+	httpGenericAuthTypeMatchesPrompt,
 	validNodeConfig,
 ];
 
diff --git a/packages/@n8n/instance-ai/evaluations/cli/compare-pairwise.ts b/packages/@n8n/instance-ai/evaluations/cli/compare-pairwise.ts
index fafbeb99db6..040e76d3cf9 100644
--- a/packages/@n8n/instance-ai/evaluations/cli/compare-pairwise.ts
+++ b/packages/@n8n/instance-ai/evaluations/cli/compare-pairwise.ts
@@ -17,6 +17,9 @@ import { jsonParse } from 'n8n-workflow';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
+import { scrubSecretsInText } from '../../src/utils/scrub-secrets';
+import { redactSecrets } from '../harness/redact';
+
 // ---------------------------------------------------------------------------
 // Shared shape after normalization
 // ---------------------------------------------------------------------------
@@ -50,6 +53,8 @@ export interface BuilderRecord {
 	toolCallErrors?: number;
 	/** Total tool calls observed, used as the error-rate denominator. */
 	toolCallsTotal?: number;
+	/** Raw tool-call trace. IA-only — populated by `loadInstanceAiRun`. */
+	toolCalls?: IAToolCallTrace[];
 }
 
 interface BuilderSummary {
@@ -190,6 +195,7 @@ async function loadInstanceAiRun(dir: string): Promise<BuilderRun> {
 			submitCalls: tcs.filter((tc) => tc.toolName === 'submit-workflow').length,
 			toolCallErrors: tcs.filter(isErroredIAToolCall).length,
 			toolCallsTotal: tcs.length,
+			toolCalls: tcs,
 		};
 	});
 
@@ -634,7 +640,7 @@ function renderBuilderColumn(label: string, record: BuilderRecord | undefined):
 	}
 
 	const errorBlock = record.errorMessage
-		? `<div class="error">${escapeHtml(record.errorMessage)}</div>`
+		? `<div class="error">${escapeHtml(scrubSecretsInText(record.errorMessage))}</div>`
 		: '';
 
 	const idLine = record.exampleId
@@ -654,12 +660,110 @@ function renderBuilderColumn(label: string, record: BuilderRecord | undefined):
 </div>`;
 }
 
-function renderRow(row: ComparisonRow, index: number): string {
+interface SideLabels {
+	ee: string;
+	ia: string;
+}
+
+function summarizeToolCallArgs(toolName: string, args: unknown): string {
+	if (!args || typeof args !== 'object') return '';
+	// Redact secret-shaped keys (password / token / api_key / …) and scrub the
+	// extracted free-form strings for known credential patterns. The same
+	// summarized text is used as a data-attribute on the row, so any leaked
+	// secret would persist in the HTML and be searchable via filter input.
+	const a = redactSecrets(args) as Record<string, unknown>;
+	const str = (v: unknown): string => (typeof v === 'string' ? scrubSecretsInText(v) : '');
+	const trunc = (s: string, n = 160): string => (s.length > n ? s.slice(0, n) + '…' : s);
+	switch (toolName) {
+		case 'mastra_workspace_execute_command':
+			return trunc(str(a.command));
+		case 'mastra_workspace_edit_file':
+			return trunc(str(a.path));
+		case 'mastra_workspace_write_file': {
+			const p = str(a.path);
+			const len = typeof a.content === 'string' ? a.content.length : 0;
+			return `${p}${len ? ` (${len} chars)` : ''}`;
+		}
+		case 'mastra_workspace_read_file': {
+			const p = str(a.path);
+			const off = typeof a.offset === 'number' ? a.offset : undefined;
+			const lim = typeof a.limit === 'number' ? a.limit : undefined;
+			const range = off !== undefined || lim !== undefined ? ` @${off ?? 0}+${lim ?? '∞'}` : '';
+			return trunc(`${p}${range}`);
+		}
+		case 'mastra_workspace_grep':
+			return trunc(`${str(a.pattern)}${a.path ? ` in ${str(a.path)}` : ''}`);
+		case 'mastra_workspace_lsp_inspect': {
+			const line = typeof a.line === 'number' ? String(a.line) : '?';
+			return trunc(`${str(a.path)}:${line} ${str(a.match)}`);
+		}
+		case 'mastra_workspace_mkdir':
+			return trunc(str(a.path));
+		case 'submit-workflow':
+			return trunc(`${str(a.name)} ${str(a.filePath)}`);
+		case 'verify-built-workflow':
+			return trunc(str(a.workflowId) || str(a.workItemId));
+		case 'credentials':
+		case 'data-tables':
+		case 'nodes':
+		case 'workflows':
+			return trunc(str(a.action));
+		default:
+			return trunc(scrubSecretsInText(JSON.stringify(a)), 120);
+	}
+}
+
+function renderToolCallRows(traces: IAToolCallTrace[]): string {
+	return traces
+		.map((tc) => {
+			const errored = isErroredIAToolCall(tc);
+			const elapsed = tc.elapsedMs !== undefined ? formatDuration(tc.elapsedMs) : '—';
+			const cls = errored ? 'tc-err' : '';
+			const argSummary = summarizeToolCallArgs(tc.toolName, tc.args);
+			const argCell = argSummary ? `<code class="tc-args">${escapeHtml(argSummary)}</code>` : '';
+			const detail = errored && tc.error ? escapeHtml(scrubSecretsInText(tc.error)) : '';
+			return `<tr class="${cls}"><td>${tc.step}</td><td>${escapeHtml(tc.toolName)}</td><td>${argCell}</td><td>${elapsed}</td><td>${detail}</td></tr>`;
+		})
+		.join('');
+}
+
+function renderToolCallsColumn(label: string, record: BuilderRecord | undefined): string {
+	if (!record) {
+		return `<div class="tc-col missing"><div class="tc-col-label">${escapeHtml(label)}</div><div class="missing-msg">No record.</div></div>`;
+	}
+	const traces = record.toolCalls ?? [];
+	if (traces.length === 0) {
+		return `<div class="tc-col"><div class="tc-col-label">${escapeHtml(label)} <span class="tc-summary">(0 calls)</span></div><div class="missing-msg">No tool calls captured.</div></div>`;
+	}
+	const errCount = traces.filter(isErroredIAToolCall).length;
+	const errBadge = errCount > 0 ? ` · <span class="tc-err-badge">${errCount} err</span>` : '';
+	return `<div class="tc-col">
+  <div class="tc-col-label">${escapeHtml(label)} <span class="tc-summary">(${traces.length} call${traces.length === 1 ? '' : 's'}${errBadge})</span></div>
+  <table class="tool-calls">
+    <thead><tr><th>#</th><th>Tool</th><th>Args</th><th>Time</th><th>Error</th></tr></thead>
+    <tbody>${renderToolCallRows(traces)}</tbody>
+  </table>
+</div>`;
+}
+
+function renderToolCallsSection(row: ComparisonRow, labels: SideLabels): string {
+	const anyTraces = (row.ee?.toolCalls?.length ?? 0) > 0 || (row.ia?.toolCalls?.length ?? 0) > 0;
+	if (!anyTraces) return '';
+	return `<details class="tool-calls-section">
+  <summary>Tool calls</summary>
+  <div class="tc-grid">
+    ${renderToolCallsColumn(labels.ee, row.ee)}
+    ${renderToolCallsColumn(labels.ia, row.ia)}
+  </div>
+</details>`;
+}
+
+function renderRow(row: ComparisonRow, index: number, labels: SideLabels): string {
 	const verdictLabel: Record<ComparisonRow['verdict'], string> = {
 		'both-pass': 'BOTH PASS',
 		'both-fail': 'BOTH FAIL',
-		'ee-only': 'CODE ONLY',
-		'ia-only': 'IA ONLY',
+		'ee-only': `${labels.ee.toUpperCase()} ONLY`,
+		'ia-only': `${labels.ia.toUpperCase()} ONLY`,
 		neither: '—',
 	};
 	const verdictCls: Record<ComparisonRow['verdict'], string> = {
@@ -690,14 +794,33 @@ function renderRow(row: ComparisonRow, index: number): string {
 	// Heavy content (workflow previews + judge tables) is wrapped in a <template>
 	// so the n8n-demo web component is NOT instantiated until the user expands
 	// the row. The lazy loader script in the document head does the swap.
-	return `<details class="row ${verdictCls[row.verdict]}" id="row-${index}">
+	const usedTools = new Set<string>();
+	const toolArgsCorpus: string[] = [];
+	for (const tc of row.ee?.toolCalls ?? []) {
+		usedTools.add(tc.toolName);
+		const summary = summarizeToolCallArgs(tc.toolName, tc.args);
+		if (summary) toolArgsCorpus.push(summary);
+	}
+	for (const tc of row.ia?.toolCalls ?? []) {
+		usedTools.add(tc.toolName);
+		const summary = summarizeToolCallArgs(tc.toolName, tc.args);
+		if (summary) toolArgsCorpus.push(summary);
+	}
+	const dataAttrs = [
+		`data-verdict="${row.verdict}"`,
+		`data-prompt="${escapeAttr(row.prompt.toLowerCase())}"`,
+		`data-id="${escapeAttr(idText.toLowerCase())}"`,
+		`data-tools="${escapeAttr([...usedTools].join(' '))}"`,
+		`data-tool-args="${escapeAttr(toolArgsCorpus.join(' ␟ ').toLowerCase())}"`,
+	].join(' ');
+	return `<details class="row ${verdictCls[row.verdict]}" id="row-${index}" ${dataAttrs}>
   <summary>
     <span class="verdict">${verdictLabel[row.verdict]}</span>
     ${idChip}
     <span class="prompt-preview">${escapeHtml(promptPreview)}</span>
     <span class="builder-chips">
-      ${builderChip('Code', eeHead)}
-      ${builderChip('IA', iaHead)}
+      ${builderChip(labels.ee, eeHead)}
+      ${builderChip(labels.ia, iaHead)}
     </span>
   </summary>
   <div class="body">
@@ -712,12 +835,13 @@ function renderRow(row: ComparisonRow, index: number): string {
     <div class="lazy-slot" data-loaded="false">
       <template>
         <div class="builder-grid">
-          ${renderBuilderColumn('Code Builder', row.ee)}
-          ${renderBuilderColumn('instance-ai', row.ia)}
+          ${renderBuilderColumn(labels.ee, row.ee)}
+          ${renderBuilderColumn(labels.ia, row.ia)}
         </div>
       </template>
       <div class="lazy-placeholder">Click to load workflow previews and judge details…</div>
     </div>
+    ${renderToolCallsSection(row, labels)}
   </div>
 </details>`;
 }
@@ -770,7 +894,7 @@ function renderMetricsNote(): string {
 </aside>`;
 }
 
-function renderVerdictTotals(rows: ComparisonRow[]): string {
+function renderVerdictTotals(rows: ComparisonRow[], labels: SideLabels): string {
 	const counts: Record<ComparisonRow['verdict'], number> = {
 		'both-pass': 0,
 		'both-fail': 0,
@@ -786,18 +910,23 @@ function renderVerdictTotals(rows: ComparisonRow[]): string {
 
 	return `<div class="verdict-grid">
   ${card('Both pass', counts['both-pass'], 'verdict-both-pass')}
-  ${card('Code Builder only passes', counts['ee-only'], 'verdict-ee-only')}
-  ${card('IA only passes', counts['ia-only'], 'verdict-ia-only')}
+  ${card(`${labels.ee} only passes`, counts['ee-only'], 'verdict-ee-only')}
+  ${card(`${labels.ia} only passes`, counts['ia-only'], 'verdict-ia-only')}
   ${card('Both fail', counts['both-fail'], 'verdict-both-fail')}
 </div>`;
 }
 
-function renderDocument(ee: BuilderRun, ia: BuilderRun, rows: ComparisonRow[]): string {
+function renderDocument(
+	ee: BuilderRun,
+	ia: BuilderRun,
+	rows: ComparisonRow[],
+	labels: SideLabels,
+): string {
 	return `<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8" />
-<title>Pairwise Eval Comparison — Code Builder vs Instance AI</title>
+<title>Pairwise Eval Comparison — ${escapeHtml(labels.ee)} vs ${escapeHtml(labels.ia)}</title>
 <script defer src="https://cdn.jsdelivr.net/npm/@webcomponents/webcomponentsjs@2.0.0/webcomponents-loader.js"></script>
 <script defer src="https://www.unpkg.com/lit@2.0.0-rc.2/polyfill-support.js"></script>
 <script type="module" src="https://cdn.jsdelivr.net/npm/@n8n_io/n8n-demo-component/n8n-demo.bundled.js"></script>
@@ -939,25 +1068,102 @@ function renderDocument(ee: BuilderRun, ia: BuilderRun, rows: ComparisonRow[]):
   table.judges tr:last-child td { border-bottom: none; }
   table.judges td.judge-pass { color: var(--pass); font-weight: 600; }
   table.judges td.judge-fail { color: var(--fail); font-weight: 600; }
+  .tool-calls-section { margin-top: 14px; border-top: 1px solid var(--border); padding-top: 10px; }
+  .tool-calls-section > summary { cursor: pointer; font-size: 13px; font-weight: 600; color: var(--fg); padding: 4px 0; user-select: none; }
+  .tool-calls-section > summary:hover { color: var(--accent, #58a6ff); }
+  .tc-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin-top: 10px; }
+  .tc-col { background: var(--card); border: 1px solid var(--border); border-radius: 6px; padding: 10px; min-width: 0; }
+  .tc-col.missing { background: var(--subtle); }
+  .tc-col-label { font-weight: 600; font-size: 12px; margin-bottom: 6px; }
+  .tc-summary { color: var(--muted); font-weight: 400; }
+  .tc-err-badge { color: var(--fail); font-weight: 600; }
+  table.tool-calls { width: 100%; border-collapse: collapse; font-size: 11px; }
+  table.tool-calls th, table.tool-calls td { padding: 4px 6px; text-align: left; border-bottom: 1px solid var(--border); vertical-align: top; }
+  table.tool-calls th { color: var(--muted); font-weight: 500; font-size: 10px; text-transform: uppercase; letter-spacing: 0.04em; }
+  table.tool-calls td:nth-child(1) { color: var(--muted); width: 28px; font-variant-numeric: tabular-nums; }
+  table.tool-calls td:nth-child(2) { white-space: nowrap; }
+  table.tool-calls td:nth-child(3) { color: var(--muted); }
+  table.tool-calls td:nth-child(4) { color: var(--muted); width: 60px; font-variant-numeric: tabular-nums; white-space: nowrap; }
+  table.tool-calls tr:last-child td { border-bottom: none; }
+  table.tool-calls tr.tc-err td { color: var(--fail); }
+  table.tool-calls tr.tc-err td:nth-child(5) { white-space: pre-wrap; word-break: break-word; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 10px; }
+  code.tc-args { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 10px; color: var(--fg); white-space: pre-wrap; word-break: break-all; display: inline-block; max-height: 60px; overflow-y: auto; }
+  .filter-bar { display: flex; gap: 10px; align-items: center; padding: 12px 16px; background: var(--card); border: 1px solid var(--border); border-radius: 6px; margin-bottom: 14px; flex-wrap: wrap; position: sticky; top: 0; z-index: 10; }
+  .filter-bar #filter-text { flex: 1 1 280px; min-width: 240px; padding: 6px 10px; background: var(--bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-size: 13px; }
+  .filter-bar #filter-text:focus { outline: none; border-color: var(--accent, #58a6ff); }
+  .filter-chip { display: inline-flex; align-items: center; gap: 5px; padding: 4px 10px; background: var(--subtle); border: 1px solid var(--border); border-radius: 16px; font-size: 12px; cursor: pointer; user-select: none; }
+  .filter-chip input { cursor: pointer; }
+  .filter-count { font-size: 12px; color: var(--muted); font-variant-numeric: tabular-nums; }
+  .filter-reset { padding: 5px 12px; background: var(--subtle); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-size: 12px; cursor: pointer; }
+  .filter-reset:hover { background: var(--card); }
 </style>
 </head>
 <body>
 <header class="top">
-  <h1>Pairwise Eval Comparison — Code Builder vs Instance AI</h1>
-  <div class="subhead">${rows.length} prompt${rows.length === 1 ? '' : 's'} compared. Rows are ordered: Code-only wins, IA-only wins, both fail, both pass.</div>
+  <h1>Pairwise Eval Comparison — ${escapeHtml(labels.ee)} vs ${escapeHtml(labels.ia)}</h1>
+  <div class="subhead">${rows.length} prompt${rows.length === 1 ? '' : 's'} compared. Rows are ordered: ${escapeHtml(labels.ee)}-only wins, ${escapeHtml(labels.ia)}-only wins, both fail, both pass.</div>
 </header>
 <main>
   <section class="summary-row">
-    ${renderSummaryCard('Code Builder', ee.summary, ee.records.length, ee.records)}
-    ${renderSummaryCard('instance-ai', ia.summary, ia.records.length, ia.records)}
+    ${renderSummaryCard(ee.summary.label || labels.ee, ee.summary, ee.records.length, ee.records)}
+    ${renderSummaryCard(ia.summary.label || labels.ia, ia.summary, ia.records.length, ia.records)}
   </section>
-  ${renderVerdictTotals(rows)}
+  ${renderVerdictTotals(rows, labels)}
   ${renderMetricsNote()}
+  <section class="filter-bar">
+    <input type="search" id="filter-text" placeholder="Filter by prompt, example id, tool name, or tool args (e.g. paths, commands)…" autocomplete="off" />
+    <label class="filter-chip"><input type="checkbox" data-verdict="both-pass" checked /> Both pass</label>
+    <label class="filter-chip"><input type="checkbox" data-verdict="ee-only" checked /> ${escapeHtml(labels.ee)} only</label>
+    <label class="filter-chip"><input type="checkbox" data-verdict="ia-only" checked /> ${escapeHtml(labels.ia)} only</label>
+    <label class="filter-chip"><input type="checkbox" data-verdict="both-fail" checked /> Both fail</label>
+    <span class="filter-count" id="filter-count">${rows.length} / ${rows.length}</span>
+    <button type="button" id="filter-reset" class="filter-reset">Reset</button>
+  </section>
   <section class="rows">
-    ${rows.map((r, i) => renderRow(r, i)).join('\n')}
+    ${rows.map((r, i) => renderRow(r, i, labels)).join('\n')}
   </section>
 </main>
 <script>
+  // Filter bar — narrows visible rows by free-text query AND verdict checkboxes.
+  (function() {
+    const input = document.getElementById('filter-text');
+    const checks = Array.from(document.querySelectorAll('.filter-bar input[type=checkbox]'));
+    const rows = Array.from(document.querySelectorAll('details.row'));
+    const counter = document.getElementById('filter-count');
+    const resetBtn = document.getElementById('filter-reset');
+    const total = rows.length;
+    function apply() {
+      const q = (input.value || '').trim().toLowerCase();
+      const verdicts = new Set(checks.filter((c) => c.checked).map((c) => c.dataset.verdict));
+      let visible = 0;
+      for (const r of rows) {
+        const v = r.dataset.verdict || '';
+        const prompt = r.dataset.prompt || '';
+        const id = r.dataset.id || '';
+        const tools = r.dataset.tools || '';
+        const toolArgs = r.dataset.toolArgs || '';
+        const passesVerdict = verdicts.has(v);
+        const passesText =
+          !q ||
+          prompt.includes(q) ||
+          id.includes(q) ||
+          tools.toLowerCase().includes(q) ||
+          toolArgs.includes(q);
+        const show = passesVerdict && passesText;
+        r.style.display = show ? '' : 'none';
+        if (show) visible++;
+      }
+      counter.textContent = visible + ' / ' + total;
+    }
+    input.addEventListener('input', apply);
+    for (const c of checks) c.addEventListener('change', apply);
+    resetBtn.addEventListener('click', () => {
+      input.value = '';
+      for (const c of checks) c.checked = true;
+      apply();
+    });
+  })();
+
   // Lazy-load heavy preview content (n8n-demo + judge tables) on first expand.
   // Each row contains <template> with the workflow previews inside a
   // .lazy-slot[data-loaded="false"] div. On the first toggle-open we move the
@@ -991,6 +1197,9 @@ interface CliArgs {
 	eeDir: string;
 	iaDir: string;
 	out: string;
+	eeAsIa: boolean;
+	eeLabel?: string;
+	iaLabel?: string;
 }
 
 function parseArgs(argv: string[]): CliArgs {
@@ -1000,21 +1209,34 @@ function parseArgs(argv: string[]): CliArgs {
 		const value = argv[idx + 1];
 		return value && !value.startsWith('--') ? value : undefined;
 	};
+	const has = (flag: string): boolean => argv.includes(flag);
 	const eeDir = get('--ee-dir');
 	const iaDir = get('--ia-dir');
 	if (!eeDir || !iaDir) {
 		throw new Error(
-			'Usage: tsx evaluations/cli/compare-pairwise.ts --ee-dir <path> --ia-dir <path> [--out <path>]',
+			'Usage: tsx evaluations/cli/compare-pairwise.ts --ee-dir <path> --ia-dir <path> [--out <path>] [--ee-as-ia] [--ee-label <name>] [--ia-label <name>]',
 		);
 	}
 	const defaultOut = path.join(path.dirname(path.resolve(iaDir)), 'comparison.html');
 	const out = path.resolve(get('--out') ?? defaultOut);
-	return { eeDir: path.resolve(eeDir), iaDir: path.resolve(iaDir), out };
+	return {
+		eeDir: path.resolve(eeDir),
+		iaDir: path.resolve(iaDir),
+		out,
+		eeAsIa: has('--ee-as-ia'),
+		eeLabel: get('--ee-label'),
+		iaLabel: get('--ia-label'),
+	};
 }
 
 async function main(): Promise<void> {
 	const args = parseArgs(process.argv.slice(2));
-	const [ee, ia] = await Promise.all([loadEERun(args.eeDir), loadInstanceAiRun(args.iaDir)]);
+	const [ee, ia] = await Promise.all([
+		args.eeAsIa ? loadInstanceAiRun(args.eeDir) : loadEERun(args.eeDir),
+		loadInstanceAiRun(args.iaDir),
+	]);
+	if (args.eeLabel) ee.summary.label = args.eeLabel;
+	if (args.iaLabel) ia.summary.label = args.iaLabel;
 
 	console.log(
 		`EE records: ${ee.records.length} (pass rate ${pct(ee.summary.totals.primaryPassRate)})`,
@@ -1027,7 +1249,11 @@ async function main(): Promise<void> {
 	const matched = rows.filter((r) => r.ee && r.ia).length;
 	console.log(`Joined ${rows.length} prompts (${matched} matched on both sides)`);
 
-	const html = renderDocument(ee, ia, rows);
+	const labels: SideLabels = {
+		ee: args.eeLabel ?? (args.eeAsIa ? 'A' : 'Code'),
+		ia: args.iaLabel ?? (args.eeAsIa ? 'B' : 'IA'),
+	};
+	const html = renderDocument(ee, ia, rows, labels);
 	await fs.writeFile(args.out, html, 'utf8');
 	console.log(`Wrote comparison report to ${args.out}`);
 }
diff --git a/packages/@n8n/instance-ai/evaluations/data/subagent/http-bearer-auth.json b/packages/@n8n/instance-ai/evaluations/data/subagent/http-bearer-auth.json
new file mode 100644
index 00000000000..f95df29aa8c
--- /dev/null
+++ b/packages/@n8n/instance-ai/evaluations/data/subagent/http-bearer-auth.json
@@ -0,0 +1,4 @@
+{
+	"id": "http-bearer-auth",
+	"prompt": "Build a workflow that runs manually, calls GET https://api.example.com/v1/items with a Bearer token, and writes the response to a file. Configure all nodes completely and don't ask me for credentials — I'll set them up later."
+}
diff --git a/packages/@n8n/instance-ai/src/agent/__tests__/system-prompt.test.ts b/packages/@n8n/instance-ai/src/agent/__tests__/system-prompt.test.ts
index a93a8c428e0..32ee87c13fa 100644
--- a/packages/@n8n/instance-ai/src/agent/__tests__/system-prompt.test.ts
+++ b/packages/@n8n/instance-ai/src/agent/__tests__/system-prompt.test.ts
@@ -1,6 +1,18 @@
 import { getSystemPrompt } from '../system-prompt';
 
 describe('getSystemPrompt', () => {
+	describe('first visible turn guidance', () => {
+		it('instructs the agent to send a concise sentence before the first tool call', () => {
+			const prompt = getSystemPrompt({});
+
+			expect(prompt).toContain('before your first tool call');
+			expect(prompt).toContain('write one short sentence');
+			expect(prompt).toContain("Keep it tied to the user's goal, not the tool name");
+			expect(prompt).toContain('Never let an empty assistant message');
+			expect(prompt).toContain('[Calling tools: ...]');
+		});
+	});
+
 	describe('license hints', () => {
 		it('includes License Limitations section when hints are provided', () => {
 			const prompt = getSystemPrompt({
diff --git a/packages/@n8n/instance-ai/src/agent/system-prompt.ts b/packages/@n8n/instance-ai/src/agent/system-prompt.ts
index d19e7c7a807..42db4bca14f 100644
--- a/packages/@n8n/instance-ai/src/agent/system-prompt.ts
+++ b/packages/@n8n/instance-ai/src/agent/system-prompt.ts
@@ -166,6 +166,8 @@ Examples: search "credential" for the credentials tool, search "file" for filesy
 
 - Be concise. Ask for clarification when intent is ambiguous.
 - No emojis unless the user explicitly requests them.
+- At the beginning of a normal user-visible turn, before your first tool call, write one short sentence explaining what you are about to do or what decision you need. Keep it tied to the user's goal, not the tool name. For system-generated background or checkpoint follow-up turns, follow the follow-up instructions.
+- Never let an empty assistant message or a \`[Calling tools: ...]\` placeholder be the first visible response.
 - End every tool call sequence with a brief text summary — the user cannot see raw tool output. Do not end your turn silently after tool calls. Exception: after spawning a background agent (\`build-workflow-with-agent\`, \`plan\`, \`create-tasks\`, \`delegate\`, \`research-with-agent\`, \`manage-data-tables-with-agent\`) the task card replaces your reply — do not write text.
 
 ## Safety
diff --git a/packages/@n8n/instance-ai/src/index.ts b/packages/@n8n/instance-ai/src/index.ts
index 73415c49498..cf79b725fb8 100644
--- a/packages/@n8n/instance-ai/src/index.ts
+++ b/packages/@n8n/instance-ai/src/index.ts
@@ -91,6 +91,7 @@ export type {
 	BackgroundTaskStatusSnapshot,
 	ConfirmationData,
 	PendingConfirmation,
+	RunStateTimeoutDetails,
 	StartedRunState,
 	SuspendedRunState,
 } from './runtime/run-state-registry';
diff --git a/packages/@n8n/instance-ai/src/runtime/__tests__/run-state-registry.test.ts b/packages/@n8n/instance-ai/src/runtime/__tests__/run-state-registry.test.ts
index b4711487d04..261bab3149d 100644
--- a/packages/@n8n/instance-ai/src/runtime/__tests__/run-state-registry.test.ts
+++ b/packages/@n8n/instance-ai/src/runtime/__tests__/run-state-registry.test.ts
@@ -1088,6 +1088,12 @@ describe('RunStateRegistry', () => {
 			const result = registry.sweepTimedOut(policy, 30_000);
 
 			expect(result.activeThreadIds).toEqual(['thread-old']);
+			expect(result.activeTimeouts['thread-old']).toMatchObject({
+				reason: 'idle_timeout',
+				surface: 'active-run',
+				timeoutMs: 30_000,
+				idleMs: 30_000,
+			});
 		});
 
 		it('identifies suspended runs older than maxAgeMs', () => {
diff --git a/packages/@n8n/instance-ai/src/runtime/resumable-stream-executor.ts b/packages/@n8n/instance-ai/src/runtime/resumable-stream-executor.ts
index fe87e226f51..40bc5f12dfe 100644
--- a/packages/@n8n/instance-ai/src/runtime/resumable-stream-executor.ts
+++ b/packages/@n8n/instance-ai/src/runtime/resumable-stream-executor.ts
@@ -60,6 +60,12 @@ export interface ExecuteResumableStreamOptions {
 	control: ResumableStreamControl;
 	initialMastraRunId?: string;
 	llmStepTraceHooks?: LlmStepTraceHooks;
+	/**
+	 * Optional side-channel observer for every mapped stream event. Used for
+	 * cross-cutting telemetry (e.g. template usage). Errors are swallowed so
+	 * the observer can never break stream consumption.
+	 */
+	onStreamEvent?: (event: InstanceAiEvent) => void;
 }
 
 export type TraceStatus = 'completed' | 'cancelled' | 'suspended' | 'errored';
@@ -1927,6 +1933,13 @@ export async function executeResumableStream(
 			);
 			if (event) {
 				workSummaryAccumulator.observe(event);
+				if (options.onStreamEvent) {
+					try {
+						options.onStreamEvent(event);
+					} catch {
+						// Side-channel observers must never break stream consumption.
+					}
+				}
 				let shouldPublishEvent = true;
 
 				if (event.type === 'confirmation-request') {
diff --git a/packages/@n8n/instance-ai/src/runtime/run-state-registry.ts b/packages/@n8n/instance-ai/src/runtime/run-state-registry.ts
index 2648967a0a5..9720d60c137 100644
--- a/packages/@n8n/instance-ai/src/runtime/run-state-registry.ts
+++ b/packages/@n8n/instance-ai/src/runtime/run-state-registry.ts
@@ -2,7 +2,11 @@ import type { InstanceAiThreadStatusResponse } from '@n8n/api-types';
 import { nanoid } from 'nanoid';
 
 import type { InstanceAiTraceContext } from '../types';
-import type { InstanceAiLivenessPolicy } from './liveness-policy';
+import type {
+	InstanceAiLivenessPolicy,
+	InstanceAiLivenessSurface,
+	InstanceAiLivenessTimeoutReason,
+} from './liveness-policy';
 
 export interface ActiveRunState {
 	runId: string;
@@ -72,6 +76,14 @@ export interface BackgroundTaskStatusSnapshot {
 	threadId: string;
 }
 
+export interface RunStateTimeoutDetails {
+	reason: InstanceAiLivenessTimeoutReason;
+	surface: InstanceAiLivenessSurface;
+	timeoutMs: number;
+	elapsedMs: number;
+	idleMs: number;
+}
+
 export interface StartRunOptions<TUser> {
 	threadId: string;
 	user: TUser;
@@ -372,8 +384,12 @@ export class RunStateRegistry<TUser = unknown> {
 		activeThreadIds: string[];
 		suspendedThreadIds: string[];
 		confirmationRequestIds: string[];
+		activeTimeouts: Record<string, RunStateTimeoutDetails>;
+		suspendedTimeouts: Record<string, RunStateTimeoutDetails>;
+		confirmationTimeouts: Record<string, RunStateTimeoutDetails>;
 	} {
 		const activeThreadIds: string[] = [];
+		const activeTimeouts: Record<string, RunStateTimeoutDetails> = {};
 		for (const [threadId, run] of this.activeRuns) {
 			if (this.hasPendingConfirmationForThread(threadId)) continue;
 
@@ -387,10 +403,12 @@ export class RunStateRegistry<TUser = unknown> {
 			});
 			if (decision.action === 'timeout') {
 				activeThreadIds.push(threadId);
+				activeTimeouts[threadId] = decision;
 			}
 		}
 
 		const suspendedThreadIds: string[] = [];
+		const suspendedTimeouts: Record<string, RunStateTimeoutDetails> = {};
 		for (const [threadId, run] of this.suspendedRuns) {
 			const startedAt = run.startedAt ?? run.createdAt;
 			const lastActivityAt = run.lastActivityAt ?? run.createdAt;
@@ -402,9 +420,11 @@ export class RunStateRegistry<TUser = unknown> {
 			});
 			if (decision.action === 'timeout') {
 				suspendedThreadIds.push(threadId);
+				suspendedTimeouts[threadId] = decision;
 			}
 		}
 		const confirmationRequestIds: string[] = [];
+		const confirmationTimeouts: Record<string, RunStateTimeoutDetails> = {};
 		for (const [reqId, pending] of this.pendingConfirmations) {
 			const startedAt = pending.startedAt ?? pending.createdAt;
 			const lastActivityAt = pending.lastActivityAt ?? pending.createdAt;
@@ -416,9 +436,17 @@ export class RunStateRegistry<TUser = unknown> {
 			});
 			if (decision.action === 'timeout') {
 				confirmationRequestIds.push(reqId);
+				confirmationTimeouts[reqId] = decision;
 			}
 		}
-		return { activeThreadIds, suspendedThreadIds, confirmationRequestIds };
+		return {
+			activeThreadIds,
+			suspendedThreadIds,
+			confirmationRequestIds,
+			activeTimeouts,
+			suspendedTimeouts,
+			confirmationTimeouts,
+		};
 	}
 
 	/**
diff --git a/packages/@n8n/instance-ai/src/stream/consume-with-hitl.ts b/packages/@n8n/instance-ai/src/stream/consume-with-hitl.ts
index ee7d0fac045..0e76bdd4aa7 100644
--- a/packages/@n8n/instance-ai/src/stream/consume-with-hitl.ts
+++ b/packages/@n8n/instance-ai/src/stream/consume-with-hitl.ts
@@ -1,4 +1,5 @@
 import type { Agent } from '@mastra/core/agent';
+import type { InstanceAiEvent } from '@n8n/api-types';
 
 import type { InstanceAiEventBus } from '../event-bus/event-bus.interface';
 import type { Logger } from '../logger';
@@ -30,6 +31,11 @@ export interface ConsumeWithHitlOptions {
 	maxSteps?: number;
 	/** Additional options to preserve when resuming a suspended stream. */
 	resumeOptions?: Record<string, unknown>;
+	/**
+	 * Optional side-channel observer for every mapped stream event. Used for
+	 * cross-cutting telemetry; errors are swallowed by the executor.
+	 */
+	onStreamEvent?: (event: InstanceAiEvent) => void;
 }
 
 export interface ConsumeWithHitlResult {
@@ -83,6 +89,7 @@ export async function consumeStreamWithHitl(
 				: {}),
 		},
 		llmStepTraceHooks: options.llmStepTraceHooks,
+		onStreamEvent: options.onStreamEvent,
 	});
 
 	return { text: result.text ?? options.stream.text, workSummary: result.workSummary };
diff --git a/packages/@n8n/instance-ai/src/tools/__tests__/credentials.tool.test.ts b/packages/@n8n/instance-ai/src/tools/__tests__/credentials.tool.test.ts
index 054457c8a7d..fcf5aa65e8b 100644
--- a/packages/@n8n/instance-ai/src/tools/__tests__/credentials.tool.test.ts
+++ b/packages/@n8n/instance-ai/src/tools/__tests__/credentials.tool.test.ts
@@ -799,6 +799,43 @@ describe('credentials tool', () => {
 			});
 		});
 
+		it('should return missing_credentials error when credentials is undefined', async () => {
+			const context = createMockContext();
+			const suspendFn = jest.fn();
+
+			const tool = createCredentialsTool(context);
+			const result = await tool.execute!(
+				{ action: 'setup', credentialFlow: { stage: 'finalize' } } as unknown as Parameters<
+					NonNullable<typeof tool.execute>
+				>[0],
+				suspendCtx(suspendFn),
+			);
+
+			expect(result).toEqual({
+				error: 'missing_credentials',
+				message: expect.stringContaining('credentials'),
+			});
+			expect(suspendFn).not.toHaveBeenCalled();
+			expect(context.credentialService.list).not.toHaveBeenCalled();
+		});
+
+		it('should return missing_credentials error when credentials is an empty array', async () => {
+			const context = createMockContext();
+			const suspendFn = jest.fn();
+
+			const tool = createCredentialsTool(context);
+			const result = await tool.execute!(
+				{ action: 'setup', credentials: [] },
+				suspendCtx(suspendFn),
+			);
+
+			expect(result).toEqual({
+				error: 'missing_credentials',
+				message: expect.stringContaining('credentials'),
+			});
+			expect(suspendFn).not.toHaveBeenCalled();
+		});
+
 		it('should default reason when not provided in credential requests', async () => {
 			const context = createMockContext();
 			(context.credentialService.list as jest.Mock).mockResolvedValue([]);
diff --git a/packages/@n8n/instance-ai/src/tools/credentials.tool.ts b/packages/@n8n/instance-ai/src/tools/credentials.tool.ts
index 9c52966a052..5cbdb6ef1c8 100644
--- a/packages/@n8n/instance-ai/src/tools/credentials.tool.ts
+++ b/packages/@n8n/instance-ai/src/tools/credentials.tool.ts
@@ -341,6 +341,14 @@ async function handleSetup(
 	const suspend = ctx?.agent?.suspend as ((payload: unknown) => Promise<void>) | undefined;
 	const isFinalize = input.credentialFlow?.stage === 'finalize';
 
+	if (!input.credentials || input.credentials.length === 0) {
+		return {
+			error: 'missing_credentials',
+			message:
+				'The `credentials` array is required for the setup action. Pass an array of { credentialType, reason?, suggestedName? } entries describing each credential to set up.',
+		};
+	}
+
 	// State 1: First call — look up existing credentials per type and suspend.
 	// Scope the lookup to `projectId` when provided so the candidates match what
 	// the workflow being built can actually use.
diff --git a/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.prompt.ts b/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.prompt.ts
index 4fb104e02af..97eba62d351 100644
--- a/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.prompt.ts
+++ b/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.prompt.ts
@@ -393,6 +393,19 @@ n8n normalizes column names to snake_case (e.g., \`dayName\` → \`day_name\`).
    execute_command: grep -i "gmail" ${workspaceRoot}/node-types/index.txt
    \`\`\`
 
+   d. **Look for similar workflow examples** in \`${workspaceRoot}/examples/\` — a curated set of real n8n workflows in SDK form. Grep the index, then read the closest match for structural inspiration:
+   \`\`\`
+   execute_command: grep -i "<keyword>" ${workspaceRoot}/examples/index.txt
+   execute_command: cat ${workspaceRoot}/examples/<file>.ts
+   \`\`\`
+   Each line in \`examples/index.txt\` is \`filename | name | nodes | tags | source-id\`. Use the example as a reference for **structure** (which credential type each node uses, how nodes are wired, where sub-nodes attach to an agent, where sticky notes go) — not as a verbatim copy. The user's request will rarely match an example one-to-one.
+
+   The \`examples/\` directory is **read-only reference**. Never edit files there; \`src/\` and \`chunks/\` are your scratch.
+
+   Examples use \`newCredential('Name', 'id')\` for clarity. When you copy a pattern into \`src/workflow.ts\`, replace those calls with raw \`{ id, name }\` from \`credentials(action="list")\` per the rules above.
+
+   If grep returns nothing, build from scratch. **Do not fabricate examples that do not exist.**
+
 3. **Get node schemas**: Call \`nodes(action="type-definition")\` with ALL the node IDs you need in a single call (up to 5). For nodes with discriminators (from search results), include the \`resource\` and \`operation\` fields. **Read the definitions carefully** — they contain exact parameter names, types, required fields, valid enum values, credential types, displayOptions conditions, and \`@builderHint\` annotations with critical configuration guidance.
    **Important**: Only call \`nodes(action="type-definition")\` for nodes you will actually use in the workflow. Do not speculatively fetch definitions "just in case". If a definition returns empty or an error, do not retry — proceed with the information from \`nodes(action="search")\` results instead.
 
diff --git a/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.tool.ts b/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.tool.ts
index 52047955e7c..7fa3871eb6c 100644
--- a/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.tool.ts
+++ b/packages/@n8n/instance-ai/src/tools/orchestration/build-workflow-agent.tool.ts
@@ -57,6 +57,13 @@ import {
 import type { BuilderWorkspace } from '../../workspace/builder-sandbox-factory';
 import { readFileViaSandbox } from '../../workspace/sandbox-fs';
 import { getWorkspaceRoot } from '../../workspace/sandbox-setup';
+import {
+	attachTemplateTelemetrySession,
+	createTemplateTelemetrySession,
+	createTypedToolObserver,
+	detachTemplateTelemetrySession,
+	type TemplateTelemetrySession,
+} from '../../workspace/template-telemetry';
 import { createCredentialsTool, type CredentialAction } from '../credentials.tool';
 import { buildCredentialSnapshot, type CredentialEntry } from '../workflows/resolve-credentials';
 import { createIdentityEnforcedSubmitWorkflowTool } from '../workflows/submit-workflow-identity';
@@ -1068,6 +1075,8 @@ export async function startBuildWorkflowAgentTask(
 				await withTraceContextActor(traceContext, async () => {
 					let builderWs: BuilderWorkspace | undefined;
 					let activeBuilderSession: BuilderSandboxSession | undefined = reusedBuilderSession;
+					let telemetrySession: TemplateTelemetrySession | undefined;
+					let telemetryWorkspace: BuilderWorkspace['workspace'] | undefined;
 					const submitAttempts = new Map<string, SubmitWorkflowAttempt>();
 					// Append-only history so a later failed submit for the main path
 					// cannot mask an earlier successful submit during post-error recovery.
@@ -1098,6 +1107,21 @@ export async function startBuildWorkflowAgentTask(
 								root = await getWorkspaceRoot(workspace);
 							}
 
+							// Bind a template-telemetry session to the workspace so any grep on
+							// examples/index.txt or cat on examples/*.ts gets observed via runInSandbox.
+							telemetrySession = createTemplateTelemetrySession({
+								context,
+								threadId: context.threadId,
+								runId: context.runId,
+								workItemId,
+								userRequestExcerpt: input.task,
+							});
+							telemetryWorkspace = workspace;
+							attachTemplateTelemetrySession(workspace, telemetrySession);
+							// Captures typed `mastra_workspace_grep` / `mastra_workspace_read_file`
+							// calls that never reach `runInSandbox` (shell-channel only).
+							const templateToolObserver = createTypedToolObserver(telemetrySession);
+
 							prompt = createSandboxBuilderAgentPrompt(root);
 							if (!activeBuilderSession && builderWs) {
 								activeBuilderSession = context.builderSandboxSessionRegistry?.create({
@@ -1294,6 +1318,7 @@ export async function startBuildWorkflowAgentTask(
 										llmStepTraceHooks,
 										maxSteps: MAX_STEPS.BUILDER,
 										resumeOptions,
+										onStreamEvent: templateToolObserver,
 									});
 								});
 
@@ -1594,6 +1619,16 @@ export async function startBuildWorkflowAgentTask(
 						await promoteMainWorkflow(domainContext, context.logger, fallbackMainWorkflowId);
 						return { text: toolFinalText };
 					} finally {
+						if (telemetrySession && telemetryWorkspace) {
+							try {
+								telemetrySession.flush();
+								detachTemplateTelemetrySession(telemetryWorkspace);
+							} catch (error) {
+								context.logger.warn('build-workflow-agent: failed to flush template telemetry', {
+									error: error instanceof Error ? error.message : String(error),
+								});
+							}
+						}
 						clearFilesystemMutationGuard?.();
 						if (activeBuilderSession && context.builderSandboxSessionRegistry) {
 							await context.builderSandboxSessionRegistry.release(activeBuilderSession.sessionId, {
diff --git a/packages/@n8n/instance-ai/src/utils/scrub-secrets.ts b/packages/@n8n/instance-ai/src/utils/scrub-secrets.ts
new file mode 100644
index 00000000000..11759f6df44
--- /dev/null
+++ b/packages/@n8n/instance-ai/src/utils/scrub-secrets.ts
@@ -0,0 +1,34 @@
+/**
+ * Replace common credential patterns in free-form text with `[REDACTED]`.
+ *
+ * Used before persisting user-supplied text (telemetry excerpts, eval report
+ * HTML) where keys/tokens accidentally pasted into prompts or command lines
+ * could otherwise leak downstream.
+ *
+ * Conservative by design: matches well-known prefixed tokens and explicit
+ * `key=value` pairs only. We don't attempt to redact arbitrary long opaque
+ * strings — false positives on file paths, IDs, or base64 payloads would
+ * make the output unreadable.
+ */
+const SECRET_VALUE_PATTERNS: readonly RegExp[] = [
+	// Authorization-header substrings: `Bearer <token>`, `Basic <token>`, `Token <token>`
+	/\b(?:Bearer|Basic|Token)\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+	// OpenAI / Anthropic API keys
+	/\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}/g,
+	// Slack tokens (xoxb, xoxp, xoxa, xoxr, xoxs, xoxo)
+	/\bxox[abprso]-[A-Za-z0-9-]{10,}/g,
+	// GitHub tokens (ghp, ghs, gho, ghr, ghu)
+	/\bgh[psoru]_[A-Za-z0-9]{20,}/g,
+	// AWS access key id
+	/\bAKIA[0-9A-Z]{16}\b/g,
+	// Generic `password=...` / `api_key=...` / `secret=...` style assignments
+	/\b(?:password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token)\s*[:=]\s*\S+/gi,
+];
+
+export function scrubSecretsInText(input: string): string {
+	let out = input;
+	for (const pattern of SECRET_VALUE_PATTERNS) {
+		out = out.replace(pattern, '[REDACTED]');
+	}
+	return out;
+}
diff --git a/packages/@n8n/instance-ai/src/workspace/__tests__/builder-sandbox-factory.test.ts b/packages/@n8n/instance-ai/src/workspace/__tests__/builder-sandbox-factory.test.ts
index 4d1e1955e89..80062bde31a 100644
--- a/packages/@n8n/instance-ai/src/workspace/__tests__/builder-sandbox-factory.test.ts
+++ b/packages/@n8n/instance-ai/src/workspace/__tests__/builder-sandbox-factory.test.ts
@@ -118,6 +118,7 @@ jest.mock('../sandbox-setup', () => ({
 	formatNodeCatalogLine: jest.fn((x: { name?: string }) => x.name ?? ''),
 	getWorkspaceRoot: jest.fn(async () => await Promise.resolve('/home/daytona/workspace')),
 	setupSandboxWorkspace: jest.fn(async () => await Promise.resolve()),
+	writeCuratedExamples: jest.fn(async () => await Promise.resolve()),
 	PACKAGE_JSON: '{}',
 	TSCONFIG_JSON: '{}',
 	BUILD_MJS: '',
@@ -231,6 +232,21 @@ describe('BuilderSandboxFactory createDaytona snapshot branching', () => {
 
 		expect(ensureSnapshotSpy).toHaveBeenCalledWith(expect.anything(), 'proxy');
 	});
+
+	it('writes curated examples into the new Daytona sandbox', async () => {
+		// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/consistent-type-imports
+		const sandboxSetup = require('../sandbox-setup') as typeof import('../sandbox-setup');
+		(sandboxSetup.writeCuratedExamples as jest.Mock).mockClear();
+
+		const config = makeDaytonaConfig();
+		const snapshotManager = new SnapshotManager('node:20', NOOP_LOGGER, '1.123.0');
+		jest.spyOn(snapshotManager, 'ensureSnapshot').mockResolvedValue('n8n/instance-ai:1.123.0');
+
+		const factory = new BuilderSandboxFactory(config, snapshotManager, NOOP_LOGGER);
+		await factory.create('builder-1', makeContext());
+
+		expect(sandboxSetup.writeCuratedExamples).toHaveBeenCalledTimes(1);
+	});
 });
 
 describe('BuilderSandboxFactory createDaytona error reporting', () => {
@@ -382,11 +398,16 @@ describe('BuilderSandboxFactory.createN8nSandbox cleanup on failure', () => {
 	});
 
 	it('returns a cleanup handle that destroys the sandbox when create succeeds', async () => {
+		// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/consistent-type-imports
+		const sandboxSetup = require('../sandbox-setup') as typeof import('../sandbox-setup');
+		(sandboxSetup.writeCuratedExamples as jest.Mock).mockClear();
+
 		const factory = new BuilderSandboxFactory(makeN8nSandboxConfig(), undefined);
 		const bw = await factory.create('b-3', makeContext());
 
 		expect(capturedSandboxes).toHaveLength(1);
 		expect(capturedSandboxes[0].destroy).not.toHaveBeenCalled();
+		expect(sandboxSetup.writeCuratedExamples).toHaveBeenCalledTimes(1);
 
 		await bw.cleanup();
 
diff --git a/packages/@n8n/instance-ai/src/workspace/__tests__/sandbox-setup.test.ts b/packages/@n8n/instance-ai/src/workspace/__tests__/sandbox-setup.test.ts
index 08770bae8c1..7da77b5cca1 100644
--- a/packages/@n8n/instance-ai/src/workspace/__tests__/sandbox-setup.test.ts
+++ b/packages/@n8n/instance-ai/src/workspace/__tests__/sandbox-setup.test.ts
@@ -171,6 +171,30 @@ describe('setupSandboxWorkspace', () => {
 		);
 	});
 
+	it('writes the curated examples bundle into examples/', async () => {
+		const runInSandbox: RunInSandboxMock = jest.fn<
+			Promise<{ exitCode: number; stdout: string; stderr: string }>,
+			[Workspace, string, string?]
+		>();
+		runInSandbox.mockResolvedValue({ exitCode: 0, stdout: '', stderr: '' });
+		const readFileViaSandbox: ReadFileViaSandboxMock = jest.fn<
+			Promise<string | null>,
+			[Workspace, string]
+		>();
+		readFileViaSandbox.mockResolvedValue(null);
+		const setupSandboxWorkspace = loadSetupSandboxWorkspaceWithFsMocks(
+			runInSandbox,
+			readFileViaSandbox,
+		);
+		const writeFile = jest.fn<Promise<void>, [string, string, { recursive: true }]>(async () => {});
+
+		await setupSandboxWorkspace(createLocalWorkspace(writeFile), createSetupContext());
+
+		const writtenPaths = writeFile.mock.calls.map(([path]) => path);
+		expect(writtenPaths).toContain('/sandbox/examples/index.txt');
+		expect(writtenPaths.some((p) => /^\/sandbox\/examples\/.+\.ts$/.test(p))).toBe(true);
+	});
+
 	it('does not write the initialized marker when npm install fails', async () => {
 		const runInSandbox: RunInSandboxMock = jest.fn<
 			Promise<{ exitCode: number; stdout: string; stderr: string }>,
diff --git a/packages/@n8n/instance-ai/src/workspace/builder-sandbox-factory.ts b/packages/@n8n/instance-ai/src/workspace/builder-sandbox-factory.ts
index 87c3a5da272..8183fc178e8 100644
--- a/packages/@n8n/instance-ai/src/workspace/builder-sandbox-factory.ts
+++ b/packages/@n8n/instance-ai/src/workspace/builder-sandbox-factory.ts
@@ -3,7 +3,8 @@
  *
  * Creates an ephemeral sandbox + workspace per builder invocation.
  * - Daytona mode: creates from pre-warmed Image (config + deps baked in),
- *   then writes the node-types catalog post-creation via filesystem API.
+ *   then writes the node-types catalog and curated examples post-creation
+ *   via filesystem API.
  * - Local mode: per-builder subdirectory with full setup (development only)
  */
 
@@ -27,7 +28,12 @@ import {
 import { runInSandbox, writeFileViaSandbox } from './sandbox-fs';
 import type { SnapshotManager } from './snapshot-manager';
 import type { InstanceAiContext } from '../types';
-import { formatNodeCatalogLine, getWorkspaceRoot, setupSandboxWorkspace } from './sandbox-setup';
+import {
+	formatNodeCatalogLine,
+	getWorkspaceRoot,
+	setupSandboxWorkspace,
+	writeCuratedExamples,
+} from './sandbox-setup';
 
 const NOOP_LOGGER: Logger = {
 	info: () => {},
@@ -266,6 +272,10 @@ export class BuilderSandboxFactory {
 				await writeFileViaSandbox(workspace, `${root}/node-types/index.txt`, catalog);
 			}
 
+			// Curated examples — also too large to bake into the image, written
+			// post-creation. Without this the builder sees an empty examples/ dir.
+			await writeCuratedExamples(workspace, this.logger);
+
 			await this.linkWorkspaceSdkIfEnabled(workspace, root);
 
 			return {
@@ -320,6 +330,8 @@ export class BuilderSandboxFactory {
 				await writeFileViaSandbox(workspace, `${root}/node-types/index.txt`, catalog);
 			}
 
+			await writeCuratedExamples(workspace, this.logger);
+
 			await this.linkWorkspaceSdkIfEnabled(workspace, root);
 
 			return {
diff --git a/packages/@n8n/instance-ai/src/workspace/sandbox-fs.ts b/packages/@n8n/instance-ai/src/workspace/sandbox-fs.ts
index 5a7b903a4da..b3634691ccc 100644
--- a/packages/@n8n/instance-ai/src/workspace/sandbox-fs.ts
+++ b/packages/@n8n/instance-ai/src/workspace/sandbox-fs.ts
@@ -11,10 +11,16 @@
 
 import type { Workspace } from '@mastra/core/workspace';
 
+import { getTemplateTelemetrySession } from './template-telemetry';
+
 /**
  * Execute a shell command in the sandbox and wait for completion.
  * Tries `executeCommand` first (auto-generated by MastraSandbox when processes
  * are provided), falls back to `processes.spawn` + wait.
+ *
+ * If a TemplateTelemetrySession is bound to the workspace via
+ * `attachTemplateTelemetrySession`, the command + stdout get observed for
+ * template-usage events. Failures in the observer never break the command.
  */
 export async function runInSandbox(
 	workspace: Workspace,
@@ -24,18 +30,28 @@ export async function runInSandbox(
 	const sandbox = workspace.sandbox;
 	if (!sandbox) throw new Error('Workspace has no sandbox');
 
+	let result: { exitCode: number; stdout: string; stderr: string };
 	if (sandbox.executeCommand) {
-		const result = await sandbox.executeCommand(command, [], { cwd });
-		return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
-	}
-
-	if (sandbox.processes) {
+		const r = await sandbox.executeCommand(command, [], { cwd });
+		result = { exitCode: r.exitCode, stdout: r.stdout, stderr: r.stderr };
+	} else if (sandbox.processes) {
 		const handle = await sandbox.processes.spawn(command, { cwd });
-		const result = await handle.wait();
-		return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+		const r = await handle.wait();
+		result = { exitCode: r.exitCode, stdout: r.stdout, stderr: r.stderr };
+	} else {
+		throw new Error('Sandbox has neither executeCommand nor processes available');
 	}
 
-	throw new Error('Sandbox has neither executeCommand nor processes available');
+	const session = getTemplateTelemetrySession(workspace);
+	if (session) {
+		try {
+			session.observe(command, result.stdout);
+		} catch {
+			// Telemetry must never fail a command. Swallow.
+		}
+	}
+
+	return result;
 }
 
 /**
diff --git a/packages/@n8n/instance-ai/src/workspace/sandbox-setup.ts b/packages/@n8n/instance-ai/src/workspace/sandbox-setup.ts
index 355239cf097..f5f59bae519 100644
--- a/packages/@n8n/instance-ai/src/workspace/sandbox-setup.ts
+++ b/packages/@n8n/instance-ai/src/workspace/sandbox-setup.ts
@@ -22,8 +22,10 @@
  */
 
 import type { Workspace } from '@mastra/core/workspace';
+import { getExampleFiles } from '@n8n/workflow-sdk/examples-loader';
 import { createRequire } from 'node:module';
 
+import type { Logger } from '../logger';
 import type { InstanceAiContext, SearchableNodeDescription } from '../types';
 import { isLinkWorkspaceSdkEnabled } from './pack-workspace-sdk';
 import { runInSandbox, readFileViaSandbox, escapeSingleQuotes } from './sandbox-fs';
@@ -315,6 +317,35 @@ export async function getWorkspaceRoot(workspace: Workspace): Promise<string> {
 	return root;
 }
 
+/**
+ * Write the curated workflow examples bundle into `${root}/examples/`.
+ *
+ * Used by `setupSandboxWorkspace` (local provider) and by the Daytona /
+ * n8n-sandbox factory paths, which skip the full setup but still need the
+ * curated reference material the builder agent greps against.
+ *
+ * No-op when the loader returns an empty bundle (e.g. running against a
+ * workspace where the manifest hasn't been fetched).
+ */
+export async function writeCuratedExamples(workspace: Workspace, logger?: Logger): Promise<void> {
+	const start = Date.now();
+	const { files: exampleFiles, indexTxt } = getExampleFiles();
+	if (exampleFiles.length === 0) return;
+
+	const root = await getWorkspaceRoot(workspace);
+	const fileMap = new Map<string, string>();
+	fileMap.set('examples/index.txt', indexTxt);
+	for (const example of exampleFiles) {
+		fileMap.set(`examples/${example.filename}`, example.content);
+	}
+	await writeWorkspaceFiles(workspace, root, fileMap);
+
+	logger?.debug('[sandbox-setup] prepared curated examples', {
+		count: exampleFiles.length,
+		durationMs: Date.now() - start,
+	});
+}
+
 /**
  * Initialize the sandbox workspace for the workflow builder agent.
  * Idempotent — skips if already initialized (checks marker file).
@@ -372,6 +403,7 @@ export async function setupSandboxWorkspace(
 	// ── Write workspace files ──────────────────────────────────────────────
 
 	await writeWorkspaceFiles(workspace, root, files);
+	await writeCuratedExamples(workspace, context.logger);
 
 	// npm install (must run after package.json is in place)
 	const npmResult = await runInSandbox(workspace, 'npm install --ignore-scripts', root);
diff --git a/packages/@n8n/instance-ai/src/workspace/template-telemetry.test.ts b/packages/@n8n/instance-ai/src/workspace/template-telemetry.test.ts
new file mode 100644
index 00000000000..c84520fd7a9
--- /dev/null
+++ b/packages/@n8n/instance-ai/src/workspace/template-telemetry.test.ts
@@ -0,0 +1,417 @@
+import type { InstanceAiEvent } from '@n8n/api-types';
+
+import {
+	createTemplateTelemetrySession,
+	createTypedToolObserver,
+	extractGrepQuery,
+	type TelemetrySessionOptions,
+} from './template-telemetry';
+import type { OrchestrationContext } from '../types';
+
+function makeOpts(): {
+	opts: TelemetrySessionOptions;
+	calls: Array<{ name: string; props: Record<string, unknown> }>;
+} {
+	const calls: Array<{ name: string; props: Record<string, unknown> }> = [];
+	const context = {
+		trackTelemetry: (name: string, props: Record<string, unknown>) => {
+			calls.push({ name, props });
+		},
+	} as unknown as OrchestrationContext;
+	return {
+		opts: {
+			context,
+			threadId: 'thread-1',
+			runId: 'run-42',
+			workItemId: 'wi_abc12345',
+			userRequestExcerpt: 'summarise emails to slack daily',
+		},
+		calls,
+	};
+}
+
+describe('createTemplateTelemetrySession', () => {
+	it('emits a search event when grep targets examples/index.txt', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe(
+			'grep -i "slack" /home/sandbox/workspace/examples/index.txt',
+			'slack-daily-summary.ts | Daily Slack ...\nother.ts | ...\n',
+		);
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		expect(search).toBeDefined();
+		expect(search!.props.query).toBe('slack');
+		expect(search!.props.result_count).toBe(2);
+		expect(search!.props.run_id).toBe('run-42');
+		expect(search!.props.work_item_id).toBe('wi_abc12345');
+	});
+
+	it('does not emit search for grep against a different file', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe('grep -i "gmail" /workspace/node-types/index.txt', 'something\n');
+		expect(calls.find((c) => c.name === 'Builder template search')).toBeUndefined();
+	});
+
+	it('emits a read event when cat targets examples/<file>.ts', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe(
+			'cat /home/sandbox/workspace/examples/slack-daily-summary.ts',
+			'/* file content here */',
+		);
+
+		const read = calls.find((c) => c.name === 'Builder template read');
+		expect(read).toBeDefined();
+		expect(read!.props.template_filename).toBe('slack-daily-summary.ts');
+		expect(read!.props.bytes_read).toBe('/* file content here */'.length);
+	});
+
+	it('handles head/sed/less/more in addition to cat', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe('head -50 /workspace/examples/slack-daily-summary.ts', 'lines');
+		session.observe('sed -n 1,30p /workspace/examples/build-your-first-ai-agent-6270.ts', 'lines');
+
+		const reads = calls.filter((c) => c.name === 'Builder template read');
+		expect(reads.length).toBe(2);
+	});
+
+	it('does not emit a read for cat on a non-template file', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe('cat /workspace/src/workflow.ts', 'content');
+		expect(calls.find((c) => c.name === 'Builder template read')).toBeUndefined();
+	});
+
+	it('emits a session rollup on flush', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe('grep -i "slack" /workspace/examples/index.txt', 'a\nb\n');
+		session.observe('cat /workspace/examples/slack-daily-summary.ts', 'X');
+		session.observe('cat /workspace/examples/slack-daily-summary.ts', 'X');
+		session.flush();
+
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		expect(rollup).toBeDefined();
+		expect(rollup!.props.search_count).toBe(1);
+		expect(rollup!.props.read_count).toBe(2);
+		expect(rollup!.props.unique_templates_read).toBe(1);
+		expect(rollup!.props.user_request_excerpt).toBe('summarise emails to slack daily');
+	});
+
+	it('truncates user_request_excerpt to 120 chars', () => {
+		const long = 'a'.repeat(200);
+		const { opts, calls } = makeOpts();
+		opts.userRequestExcerpt = long;
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		expect(rollup!.props.user_request_excerpt).toHaveLength(120);
+	});
+
+	it('flush is idempotent and stops further events', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		session.observe('cat /workspace/examples/foo.ts', 'X');
+		session.flush();
+		expect(calls.filter((c) => c.name === 'Builder template session').length).toBe(1);
+		expect(calls.filter((c) => c.name === 'Builder template read').length).toBe(0);
+	});
+
+	it('sets user_request_excerpt to null when none provided', () => {
+		const { opts, calls } = makeOpts();
+		opts.userRequestExcerpt = undefined;
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		expect(rollup!.props.user_request_excerpt).toBeNull();
+	});
+
+	it('redacts API keys and bearer tokens from user_request_excerpt', () => {
+		const { opts, calls } = makeOpts();
+		opts.userRequestExcerpt =
+			'call openai with sk-proj-abcdef0123456789 and slack xoxb-1234567890-abcdef';
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		const excerpt = rollup!.props.user_request_excerpt as string;
+		expect(excerpt).not.toContain('sk-proj-abcdef0123456789');
+		expect(excerpt).not.toContain('xoxb-1234567890-abcdef');
+		expect(excerpt).toContain('[REDACTED]');
+	});
+
+	it('redacts password=... assignments from user_request_excerpt', () => {
+		const { opts, calls } = makeOpts();
+		opts.userRequestExcerpt = 'connect to db with password=hunter2 and api_key=secret123';
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		const excerpt = rollup!.props.user_request_excerpt as string;
+		expect(excerpt).not.toContain('hunter2');
+		expect(excerpt).not.toContain('secret123');
+		expect(excerpt).toContain('[REDACTED]');
+	});
+
+	it('leaves normal English prompts unchanged', () => {
+		const { opts, calls } = makeOpts();
+		opts.userRequestExcerpt = 'summarise emails to slack daily';
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		expect(rollup!.props.user_request_excerpt).toBe('summarise emails to slack daily');
+	});
+});
+
+describe('extractGrepQuery', () => {
+	it('extracts double-quoted patterns', () => {
+		expect(extractGrepQuery('grep -i "slack post" examples/index.txt')).toBe('slack post');
+	});
+
+	it('extracts single-quoted patterns', () => {
+		expect(extractGrepQuery("grep -i 'gmail' examples/index.txt")).toBe('gmail');
+	});
+
+	it('extracts bare patterns when unquoted', () => {
+		expect(extractGrepQuery('grep slack examples/index.txt')).toBe('slack');
+		expect(extractGrepQuery('grep -i slack examples/index.txt')).toBe('slack');
+	});
+
+	it('caps the query at 200 characters', () => {
+		const long = 'x'.repeat(300);
+		const result = extractGrepQuery(`grep -i "${long}" examples/index.txt`);
+		expect(result.length).toBe(200);
+	});
+
+	it('returns empty string when no pattern found', () => {
+		expect(extractGrepQuery('grep')).toBe('');
+	});
+});
+
+describe('observeTypedRead / observeTypedSearch', () => {
+	it('observeTypedRead emits a read event with filename and bytes', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observeTypedRead('slack-daily-summary.ts', 1234);
+
+		const read = calls.find((c) => c.name === 'Builder template read');
+		expect(read).toBeDefined();
+		expect(read!.props.template_filename).toBe('slack-daily-summary.ts');
+		expect(read!.props.bytes_read).toBe(1234);
+		expect(read!.props.run_id).toBe('run-42');
+		expect(read!.props.work_item_id).toBe('wi_abc12345');
+	});
+
+	it('observeTypedSearch emits a search event with query and result count', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observeTypedSearch('slack', 5);
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		expect(search).toBeDefined();
+		expect(search!.props.query).toBe('slack');
+		expect(search!.props.result_count).toBe(5);
+	});
+
+	it('typed observations contribute to the session rollup', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observeTypedSearch('slack', 3);
+		session.observeTypedRead('slack-daily-summary.ts', 100);
+		session.observeTypedRead('slack-daily-summary.ts', 50);
+		session.flush();
+
+		const rollup = calls.find((c) => c.name === 'Builder template session');
+		expect(rollup!.props.search_count).toBe(1);
+		expect(rollup!.props.read_count).toBe(2);
+		expect(rollup!.props.unique_templates_read).toBe(1);
+	});
+
+	it('typed methods are no-ops after flush', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.flush();
+		session.observeTypedRead('foo.ts', 10);
+		session.observeTypedSearch('foo', 1);
+		expect(calls.filter((c) => c.name === 'Builder template read')).toHaveLength(0);
+		expect(calls.filter((c) => c.name === 'Builder template search')).toHaveLength(0);
+	});
+
+	it('truncates typed search query to the query cap', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observeTypedSearch('x'.repeat(300), 1);
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		expect(typeof search!.props.query).toBe('string');
+		expect((search!.props.query as string).length).toBe(200);
+	});
+
+	it('redacts secrets from typed search query before emit', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observeTypedSearch('Bearer abcdef0123456789ABCDEF and password=hunter2', 1);
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		const query = search!.props.query as string;
+		expect(query).not.toContain('abcdef0123456789ABCDEF');
+		expect(query).not.toContain('hunter2');
+		expect(query).toContain('[REDACTED]');
+	});
+
+	it('redacts secrets from grep-derived search query before emit', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		session.observe(
+			'grep -i "sk-proj-abcdef0123456789xyz" /workspace/examples/index.txt',
+			'nothing\n',
+		);
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		const query = search!.props.query as string;
+		expect(query).not.toContain('sk-proj-abcdef0123456789xyz');
+		expect(query).toContain('[REDACTED]');
+	});
+});
+
+describe('createTypedToolObserver', () => {
+	function toolCall(
+		toolCallId: string,
+		toolName: string,
+		args: Record<string, unknown>,
+	): InstanceAiEvent {
+		return {
+			type: 'tool-call',
+			runId: 'run-42',
+			agentId: 'agent-1',
+			payload: { toolCallId, toolName, args },
+		};
+	}
+	function toolResult(toolCallId: string, result: unknown): InstanceAiEvent {
+		return {
+			type: 'tool-result',
+			runId: 'run-42',
+			agentId: 'agent-1',
+			payload: { toolCallId, result },
+		};
+	}
+	function toolError(toolCallId: string, error: string): InstanceAiEvent {
+		return {
+			type: 'tool-error',
+			runId: 'run-42',
+			agentId: 'agent-1',
+			payload: { toolCallId, error },
+		};
+	}
+
+	it('emits typed read for mastra_workspace_read_file targeting examples/<slug>.ts', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(
+			toolCall('tc-1', 'mastra_workspace_read_file', {
+				path: '/workspace/examples/slack-daily-summary.ts',
+			}),
+		);
+		observe(
+			toolResult(
+				'tc-1',
+				'/workspace/examples/slack-daily-summary.ts (200 bytes)\nfile content here\n',
+			),
+		);
+
+		const read = calls.find((c) => c.name === 'Builder template read');
+		expect(read).toBeDefined();
+		expect(read!.props.template_filename).toBe('slack-daily-summary.ts');
+		expect(read!.props.bytes_read).toBeGreaterThan(0);
+	});
+
+	it('emits typed search for mastra_workspace_grep targeting examples/', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(toolCall('tc-2', 'mastra_workspace_grep', { pattern: 'slack', path: 'examples/' }));
+		observe(toolResult('tc-2', 'examples/a.ts:1:1: slack\nexamples/b.ts:5:1: slack\n'));
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		expect(search).toBeDefined();
+		expect(search!.props.query).toBe('slack');
+		expect(search!.props.result_count).toBe(2);
+	});
+
+	it('emits typed search for grep targeting examples/index.txt', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(
+			toolCall('tc-3', 'mastra_workspace_grep', { pattern: 'slack', path: 'examples/index.txt' }),
+		);
+		observe(toolResult('tc-3', 'slack-daily.ts | Daily Slack\nslack-onboard.ts | Onboard\n'));
+
+		const search = calls.find((c) => c.name === 'Builder template search');
+		expect(search!.props.result_count).toBe(2);
+	});
+
+	it('ignores read_file outside examples/', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(toolCall('tc-x', 'mastra_workspace_read_file', { path: '/workspace/src/workflow.ts' }));
+		observe(toolResult('tc-x', 'content'));
+
+		expect(calls.find((c) => c.name === 'Builder template read')).toBeUndefined();
+	});
+
+	it('ignores grep that does not target examples/', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(toolCall('tc-y', 'mastra_workspace_grep', { pattern: 'foo', path: 'src/' }));
+		observe(toolResult('tc-y', 'src/a.ts:1:1: foo\n'));
+
+		expect(calls.find((c) => c.name === 'Builder template search')).toBeUndefined();
+	});
+
+	it('ignores unrelated tools', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(
+			toolCall('tc-z', 'mastra_workspace_write_file', { path: 'examples/foo.ts', content: 'x' }),
+		);
+		observe(toolResult('tc-z', 'ok'));
+
+		expect(calls.find((c) => c.name === 'Builder template read')).toBeUndefined();
+		expect(calls.find((c) => c.name === 'Builder template search')).toBeUndefined();
+	});
+
+	it('does not emit on tool-error and clears pending state', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(toolCall('tc-e', 'mastra_workspace_read_file', { path: 'examples/foo.ts' }));
+		observe(toolError('tc-e', 'permission denied'));
+
+		expect(calls.find((c) => c.name === 'Builder template read')).toBeUndefined();
+	});
+
+	it('handles non-string results gracefully (no emission)', () => {
+		const { opts, calls } = makeOpts();
+		const session = createTemplateTelemetrySession(opts);
+		const observe = createTypedToolObserver(session);
+
+		observe(toolCall('tc-n', 'mastra_workspace_read_file', { path: 'examples/foo.ts' }));
+		observe(toolResult('tc-n', { not: 'a string' }));
+
+		expect(calls.find((c) => c.name === 'Builder template read')).toBeUndefined();
+	});
+});
diff --git a/packages/@n8n/instance-ai/src/workspace/template-telemetry.ts b/packages/@n8n/instance-ai/src/workspace/template-telemetry.ts
new file mode 100644
index 00000000000..430140c9957
--- /dev/null
+++ b/packages/@n8n/instance-ai/src/workspace/template-telemetry.ts
@@ -0,0 +1,272 @@
+/**
+ * Template usage telemetry for the builder agent.
+ *
+ * Pattern-detects template-related shell commands (grep on `examples/index.txt`,
+ * cat/head/sed on `examples/*.ts`) and emits three event types via the existing
+ * `context.trackTelemetry?.(name, props)` channel:
+ *
+ *   - `Builder template search` — fired per index grep, with the search query
+ *   - `Builder template read`   — fired per template file read, with the filename
+ *   - `Builder template session`— fired once per builder run on flush(), with rollups
+ *
+ * Sessions are attached to a workspace via `attachTemplateTelemetrySession`
+ * (a per-Workspace WeakMap binding). `runInSandbox` looks the session up and
+ * calls `observe()` after each command — no caller-side threading required.
+ */
+import type { Workspace } from '@mastra/core/workspace';
+import type { InstanceAiEvent } from '@n8n/api-types';
+
+import type { OrchestrationContext } from '../types';
+import { scrubSecretsInText } from '../utils/scrub-secrets';
+
+const MAX_QUERY_LENGTH = 200;
+const MAX_USER_REQUEST_LENGTH = 120;
+
+const SEARCH_PATTERN = /\bgrep\b[^|]*\bexamples\/index\.txt\b/;
+const READ_COMMAND_HEADS = ['cat', 'head', 'tail', 'sed', 'less', 'more'];
+// Match `examples/<slug>.ts` anywhere in the path. `\b` boundaries reject
+// `someotherexamples/...` while accepting `/abs/path/examples/foo.ts`.
+const READ_FILE_PATTERN = /\bexamples\/([a-zA-Z0-9._-]+\.ts)\b/;
+
+export interface TemplateTelemetrySession {
+	/** Inspect a command + its stdout; emits search/read events when patterns match. */
+	observe(command: string, stdout: string): void;
+	/** Emit a `Builder template read` event for a typed tool invocation. */
+	observeTypedRead(filename: string, bytesRead: number): void;
+	/** Emit a `Builder template search` event for a typed tool invocation. */
+	observeTypedSearch(query: string, resultCount: number): void;
+	/** Emit the session rollup event and clear state. Idempotent. */
+	flush(): void;
+	/** Return true when the session has not been flushed yet. */
+	isOpen(): boolean;
+}
+
+export interface TelemetrySessionOptions {
+	context: OrchestrationContext;
+	threadId?: string;
+	runId: string;
+	workItemId: string;
+	/** Optional NL request from the user; truncated to 120 chars. */
+	userRequestExcerpt?: string;
+}
+
+export function createTemplateTelemetrySession(
+	opts: TelemetrySessionOptions,
+): TemplateTelemetrySession {
+	const baseProps = {
+		thread_id: opts.threadId,
+		run_id: opts.runId,
+		work_item_id: opts.workItemId,
+	};
+
+	let searchCount = 0;
+	let readCount = 0;
+	const templatesRead: string[] = [];
+	let open = true;
+
+	function emit(name: string, extra: Record<string, unknown>) {
+		opts.context.trackTelemetry?.(name, { ...baseProps, ...extra });
+	}
+
+	function observeTypedRead(filename: string, bytesRead: number): void {
+		if (!open) return;
+		readCount++;
+		templatesRead.push(filename);
+		emit('Builder template read', {
+			template_filename: filename,
+			bytes_read: bytesRead,
+		});
+	}
+
+	function observeTypedSearch(query: string, resultCount: number): void {
+		if (!open) return;
+		searchCount++;
+		emit('Builder template search', {
+			query: scrubAndTruncateQuery(query),
+			result_count: resultCount,
+		});
+	}
+
+	function observe(command: string, stdout: string): void {
+		if (!open) return;
+
+		// Search detection: any grep at examples/index.txt
+		if (SEARCH_PATTERN.test(command)) {
+			searchCount++;
+			emit('Builder template search', {
+				query: scrubAndTruncateQuery(extractGrepQuery(command)),
+				result_count: countResultLines(stdout),
+			});
+		}
+
+		// Read detection: cat/head/sed/etc. against examples/*.ts
+		const head = command.trim().split(/\s+/, 1)[0]?.split('/').pop() ?? '';
+		if (READ_COMMAND_HEADS.includes(head)) {
+			const match = command.match(READ_FILE_PATTERN);
+			if (match) {
+				const filename = match[1];
+				readCount++;
+				templatesRead.push(filename);
+				emit('Builder template read', {
+					template_filename: filename,
+					bytes_read: stdout.length,
+				});
+			}
+		}
+	}
+
+	function flush(): void {
+		if (!open) return;
+		open = false;
+		emit('Builder template session', {
+			search_count: searchCount,
+			read_count: readCount,
+			templates_read: templatesRead,
+			unique_templates_read: Array.from(new Set(templatesRead)).length,
+			user_request_excerpt: opts.userRequestExcerpt
+				? truncate(scrubSecretsInText(opts.userRequestExcerpt), MAX_USER_REQUEST_LENGTH)
+				: null,
+		});
+	}
+
+	return {
+		observe,
+		observeTypedRead,
+		observeTypedSearch,
+		flush,
+		isOpen: () => open,
+	};
+}
+
+/** Pull the user's grep query out of the command string. Best-effort; capped. */
+export function extractGrepQuery(command: string): string {
+	// Match: grep [-flags] "pattern" path  OR  grep [-flags] 'pattern' path  OR  grep -i pattern path
+	// First try quoted forms, then a bare token
+	const quoted = command.match(/grep\b[^"']*["']([^"']*)["']/);
+	if (quoted) return truncate(quoted[1], MAX_QUERY_LENGTH);
+	const bare = command.match(/grep\b\s+(?:-[a-zA-Z]+\s+)*([^\s|]+)/);
+	if (bare) return truncate(bare[1], MAX_QUERY_LENGTH);
+	return '';
+}
+
+function countResultLines(stdout: string): number {
+	if (!stdout) return 0;
+	const trimmed = stdout.replace(/\n+$/, '');
+	if (trimmed.length === 0) return 0;
+	return trimmed.split('\n').length;
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return s.slice(0, max);
+}
+
+/**
+ * Scrub credential patterns from a grep query, then enforce the size cap.
+ * Scrub-before-truncate prevents a secret that straddles the cap from
+ * surviving in a half-form the regex no longer matches.
+ */
+function scrubAndTruncateQuery(query: string): string {
+	return truncate(scrubSecretsInText(query), MAX_QUERY_LENGTH);
+}
+
+// ---------------------------------------------------------------------------
+// Workspace binding
+// ---------------------------------------------------------------------------
+
+const SESSIONS = new WeakMap<Workspace, TemplateTelemetrySession>();
+
+/** Bind a session to a workspace so `runInSandbox` can pick it up automatically. */
+export function attachTemplateTelemetrySession(
+	workspace: Workspace,
+	session: TemplateTelemetrySession,
+): void {
+	SESSIONS.set(workspace, session);
+}
+
+/** Remove the session binding. Safe to call multiple times. */
+export function detachTemplateTelemetrySession(workspace: Workspace): void {
+	SESSIONS.delete(workspace);
+}
+
+/** Internal: look up the session bound to a workspace, if any. */
+export function getTemplateTelemetrySession(
+	workspace: Workspace,
+): TemplateTelemetrySession | undefined {
+	return SESSIONS.get(workspace);
+}
+
+// ---------------------------------------------------------------------------
+// Typed-tool observation (covers `mastra_workspace_grep` / `mastra_workspace_read_file`,
+// which never reach `runInSandbox` and so wouldn't otherwise be captured.)
+// ---------------------------------------------------------------------------
+
+const TYPED_READ_TOOL = 'mastra_workspace_read_file';
+const TYPED_GREP_TOOL = 'mastra_workspace_grep';
+
+// Path either is `examples` itself or sits under it: `examples`, `examples/`,
+// `examples/foo.ts`, `/abs/examples/`, etc. Rejects `someexamples`, `examples-x`.
+const EXAMPLES_PATH_PATTERN = /(?:^|\/)examples(?:$|\/)/;
+
+type PendingTypedCall = { kind: 'read'; filename: string } | { kind: 'search'; query: string };
+
+/**
+ * Pair `tool-call` + `tool-result` events for typed Mastra workspace tools and
+ * forward template accesses to the session. Returned function is meant to be
+ * fed every event from the agent's stream (e.g. via consume-with-hitl's
+ * `onStreamEvent` hook). Maintains pending state per `toolCallId`.
+ */
+export function createTypedToolObserver(
+	session: TemplateTelemetrySession,
+): (event: InstanceAiEvent) => void {
+	const pending = new Map<string, PendingTypedCall>();
+
+	return (event) => {
+		if (!session.isOpen()) return;
+
+		if (event.type === 'tool-call') {
+			const matched = matchTypedTemplateCall(event.payload.toolName, event.payload.args);
+			if (matched) pending.set(event.payload.toolCallId, matched);
+			return;
+		}
+
+		if (event.type === 'tool-result') {
+			const match = pending.get(event.payload.toolCallId);
+			if (!match) return;
+			pending.delete(event.payload.toolCallId);
+
+			const result = event.payload.result;
+			if (typeof result !== 'string') return;
+
+			if (match.kind === 'read') {
+				session.observeTypedRead(match.filename, result.length);
+			} else {
+				session.observeTypedSearch(match.query, countResultLines(result));
+			}
+			return;
+		}
+
+		if (event.type === 'tool-error') {
+			pending.delete(event.payload.toolCallId);
+		}
+	};
+}
+
+function matchTypedTemplateCall(
+	toolName: string,
+	args: Record<string, unknown>,
+): PendingTypedCall | undefined {
+	if (toolName === TYPED_READ_TOOL) {
+		const path = typeof args.path === 'string' ? args.path : '';
+		const match = path.match(READ_FILE_PATTERN);
+		if (!match) return undefined;
+		return { kind: 'read', filename: match[1] };
+	}
+	if (toolName === TYPED_GREP_TOOL) {
+		const path = typeof args.path === 'string' ? args.path : '';
+		if (!EXAMPLES_PATH_PATTERN.test(path)) return undefined;
+		const pattern = typeof args.pattern === 'string' ? args.pattern : '';
+		return { kind: 'search', query: pattern };
+	}
+	return undefined;
+}
diff --git a/packages/@n8n/workflow-sdk/.gitignore b/packages/@n8n/workflow-sdk/.gitignore
index a618f6ee487..976aee62336 100644
--- a/packages/@n8n/workflow-sdk/.gitignore
+++ b/packages/@n8n/workflow-sdk/.gitignore
@@ -12,3 +12,11 @@ test-fixtures/real-workflows/*.generated.ts
 scripts/*.js
 scripts/*.js.map
 scripts/*.d.ts
+
+# Curation pipeline intermediates (committed: manifest.json, templates.zip, _calibration.json, _coverage-report.json)
+examples/_raw/
+examples/_failures.log
+examples/_catalog-snapshot.json
+
+# Workflow JSONs are extracted from templates.zip at runtime — only the zip is committed
+examples/workflows/
diff --git a/packages/@n8n/workflow-sdk/docs/template-criteria.md b/packages/@n8n/workflow-sdk/docs/template-criteria.md
new file mode 100644
index 00000000000..290c0f4f038
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/docs/template-criteria.md
@@ -0,0 +1,95 @@
+# Template helpfulness criteria
+
+This rubric scores public n8n.io workflows for inclusion in `examples/manifest.json`,
+the curated set the instance-ai builder agent grep over while building. The rubric —
+not the resulting list — is the durable artifact: re-run `pnpm regenerate-examples`
+against a fresh catalog to refresh picks. See `scripts/criteria.ts` for the
+implementation; tune weights there.
+
+## What "helpful" means
+
+A template is helpful if it (a) reflects a real-world pattern the agent will be
+asked to build, (b) is structurally clear enough to reason about, and (c) adds
+something the rest of the set doesn't.
+
+## Mechanical viability gate (drop on fail)
+
+Hard filters applied before scoring. Anything failing here is dropped, regardless
+of other signals.
+
+| Filter | Rule | Stage |
+|---|---|---|
+| Published | `status == 'published'` | detail |
+| Free | `purchaseUrl == null` AND (`price` is null/undefined OR `price <= 0`) | catalog |
+| Size upper bound | `nodes.length <= 40` (list count is sparse) | catalog |
+| Size full range | `workflow.nodes.length` in `[3, 40]` | detail |
+| Verified author | `user.verified == true` | catalog |
+| Has trigger | At least one node whose type identifies as a trigger | detail |
+
+Verified-author and node-count filters drop ~30% of the catalog combined; the
+trade-off is quality density over breadth.
+
+## Scoring dimensions
+
+Six dimensions sum to a relative total. Weights are numbers in `criteria.ts`; the
+manifest entry records each dimension's score so picks stay reviewable.
+
+| Dimension | Weight | Signal |
+|---|---|---|
+| **Real-world traction** | 20 | `log10(totalViews + 1)` + `log10(recentViews + 1)` |
+| **Recency** | 20 | linear decay from 1.0 (≤90d since `updatedAt`) to 0.0 (≥2y) |
+| **Pattern coverage (marginal)** | 35 | `1.0 / (1 + countInBucket(running_set))` — bucket = `(triggerType, primaryIntegration, hasAI, controlFlowKind)`; recomputed as each pick is accepted |
+| **AI-agent relevance** | 0 | Folded into bucket key (`hasAI`); no extra weight. Diversity bucketing alone delivers ~50% AI representation. |
+| **Structural clarity** | 15 | `+0.4` if median node has a non-default name (not `Edit Fields1`, `HTTP Request2`); `+0.3` if has ≥1 sticky note; `+0.3` if has ≥3 distinct node types |
+| **Pedagogical density** | 5 | `min(1, distinctNodeTypes / nodeCount)` — favours patterns over repetition |
+
+### Why coverage dominates (35)
+
+Pattern coverage is the heaviest weight. The builder agent needs to grep
+across many distinct shapes (trigger types, integration mixes, control flow
+patterns), not 100 copies of "schedule → openAi → slack." Each pick's coverage
+score recomputes after the running set updates, so popular-but-redundant
+candidates lose ground.
+
+### Why AI bias is 0
+
+The catalog is already ~53% AI-rich. The bucket key includes `hasAI`, so
+round-robin selection naturally gives AI workflows ~50% of slots. Adding an
+explicit AI bonus on top would over-fit. If telemetry later shows the agent
+under-uses AI templates, lift this weight.
+
+### Why traction is `log10(views) + log10(recentViews)`
+
+Views distribution is wildly skewed (median 1, max 780k). Log-scale compresses
+the long tail into a usable range. Adding recent views (last 30d) catches
+"currently popular" alongside "historically popular."
+
+## Diversity bucket
+
+`bucketKey(detail) = (triggerType, primaryIntegration, hasAI, controlFlowKind)`
+
+- `triggerType` ∈ `{webhook, schedule, chatTrigger, formTrigger, manual, telegram, gmail, other}`
+- `primaryIntegration` — vendor prefix of the most-frequent non-trigger node (e.g. `googleSheets`, `slack`, `openAi`, `telegram`)
+- `hasAI` ∈ `{true, false}` — any `@n8n/n8n-nodes-langchain.*` node OR any `openAi`/`anthropic` chat model
+- `controlFlowKind` ∈ `{linear, branching, loop, parallel}` — derived from connections: branching = ifElse/switch present, loop = splitInBatches present, parallel = ≥1 node with multiple downstream connections, else linear
+
+Selection is a rescoring loop: each round picks the candidate with the highest
+total after recomputing scores against the running set. The coverage term
+(`1 / (1 + countInBucket)`) biases toward underrepresented buckets without
+enforcing strict round-robin.
+
+## Calibration
+
+`pnpm criteria:calibrate` runs the rubric against `examples/_calibration.json`
+(20–30 hand-tagged workflows) and reports:
+
+- Spearman correlation between rubric rank and expert verdict
+- Top disagreements with explanations
+
+We tune weights until correlation ≥ 0.7 on the calibration set.
+
+## Coverage check
+
+`pnpm criteria:coverage` checks the candidate set against real builder prompts
+in `packages/@n8n/instance-ai/evaluations/data/workflows/`. Coverage = % of eval
+prompts where at least one template matches ≥2 keywords. Phase 1 ships at ≥70%.
diff --git a/packages/@n8n/workflow-sdk/examples/_calibration.json b/packages/@n8n/workflow-sdk/examples/_calibration.json
new file mode 100644
index 00000000000..a349bf681ed
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/examples/_calibration.json
@@ -0,0 +1,245 @@
+{
+	"instructions": "For each entry, set verdict to \"helpful\" | \"borderline\" | \"not-helpful\" and add a one-line rationale. This becomes the calibration set.",
+	"expert_tagged": [
+		{
+			"id": 6270,
+			"rank": 1,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Build Your First AI Agent",
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"nodeCount": 7,
+			"score": 95,
+			"source": "https://n8n.io/workflows/6270"
+		},
+		{
+			"id": 8237,
+			"rank": 2,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Personal Life Manager with Telegram, Google Services & Voice-Enabled AI",
+			"triggerType": "telegram",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 90.95,
+			"source": "https://n8n.io/workflows/8237"
+		},
+		{
+			"id": 2753,
+			"rank": 3,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "RAG Chatbot for Company Documents using Google Drive and Gemini",
+			"triggerType": "other",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 90.35,
+			"source": "https://n8n.io/workflows/2753"
+		},
+		{
+			"id": 4846,
+			"rank": 4,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Generate AI Videos with Google Veo3, Save to Google Drive and Upload to YouTube",
+			"triggerType": "manual",
+			"hasAI": true,
+			"nodeCount": 10,
+			"score": 90.19,
+			"source": "https://n8n.io/workflows/4846"
+		},
+		{
+			"id": 4352,
+			"rank": 5,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "AI-Powered Multi-Social Media Post Automation: Google Trends & Perplexity AI ",
+			"triggerType": "schedule",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 89.9,
+			"source": "https://n8n.io/workflows/4352"
+		},
+		{
+			"id": 5148,
+			"rank": 6,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Local Chatbot with Retrieval Augmented Generation (RAG)",
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"nodeCount": 10,
+			"score": 89.7,
+			"source": "https://n8n.io/workflows/5148"
+		},
+		{
+			"id": 4966,
+			"rank": 7,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Customer Support WhatsApp Bot with Google Docs Knowledge Base and Gemini AI",
+			"triggerType": "other",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 89.7,
+			"source": "https://n8n.io/workflows/4966"
+		},
+		{
+			"id": 5626,
+			"rank": 8,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Free AI Image Generator - n8n Automation Workflow with Gemini/ChatGPT",
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"nodeCount": 10,
+			"score": 89.61,
+			"source": "https://n8n.io/workflows/5626"
+		},
+		{
+			"id": 5338,
+			"rank": 9,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Generate AI Viral Videos with Seedance and Upload to TikTok, YouTube & Instagram",
+			"triggerType": "schedule",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 89.35,
+			"source": "https://n8n.io/workflows/5338"
+		},
+		{
+			"id": 4827,
+			"rank": 10,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "AI-Powered WhatsApp Chatbot for Text, Voice, Images, and PDF with RAG",
+			"triggerType": "manual",
+			"hasAI": true,
+			"nodeCount": 18,
+			"score": 89.26,
+			"source": "https://n8n.io/workflows/4827"
+		},
+		{
+			"id": 5110,
+			"rank": 11,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Create & Upload AI-Generated ASMR YouTube Shorts with Seedance, Fal AI, and GPT-4",
+			"triggerType": "schedule",
+			"hasAI": true,
+			"nodeCount": 13,
+			"score": 88.91,
+			"source": "https://n8n.io/workflows/5110"
+		},
+		{
+			"id": 5385,
+			"rank": 12,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Lead Generation System: Google Maps to Email Scraper with Google Sheets Export",
+			"triggerType": "manual",
+			"hasAI": false,
+			"nodeCount": 11,
+			"score": 88.89,
+			"source": "https://n8n.io/workflows/5385"
+		},
+		{
+			"id": 5678,
+			"rank": 13,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Automate Email Filtering & AI Summarization. 100% free & effective, works 7/24 ",
+			"triggerType": "gmail",
+			"hasAI": true,
+			"nodeCount": 7,
+			"score": 88.39,
+			"source": "https://n8n.io/workflows/5678"
+		},
+		{
+			"id": 2860,
+			"rank": 14,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "AI Automated HR Workflow for CV Analysis and Candidate Evaluation",
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 88.38,
+			"source": "https://n8n.io/workflows/2860"
+		},
+		{
+			"id": 5962,
+			"rank": 15,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Track SEO Keyword Rankings with Bright Data MCP and GPT-4o AI Analysis",
+			"triggerType": "schedule",
+			"hasAI": true,
+			"nodeCount": 10,
+			"score": 88.29,
+			"source": "https://n8n.io/workflows/5962"
+		},
+		{
+			"id": 10000,
+			"rank": 16,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Auto-Create TikTok Videos with VEED.io AI Avatars, ElevenLabs & GPT-4",
+			"triggerType": "telegram",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 87.92,
+			"source": "https://n8n.io/workflows/10000"
+		},
+		{
+			"id": 3586,
+			"rank": 17,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "AI-Powered WhatsApp Chatbot 🤖📲 for Text, Voice, Images & PDFs with memory 🧠",
+			"triggerType": "other",
+			"hasAI": true,
+			"nodeCount": 13,
+			"score": 87.87,
+			"source": "https://n8n.io/workflows/3586"
+		},
+		{
+			"id": 13270,
+			"rank": 18,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Use skills In n8n agent node",
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"nodeCount": 12,
+			"score": 87.62,
+			"source": "https://n8n.io/workflows/13270"
+		},
+		{
+			"id": 4484,
+			"rank": 19,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "Build a Voice AI Chatbot with ElevenLabs and InfraNodus Knowledge Experts",
+			"triggerType": "webhook",
+			"hasAI": true,
+			"nodeCount": 8,
+			"score": 87.53,
+			"source": "https://n8n.io/workflows/4484"
+		},
+		{
+			"id": 2846,
+			"rank": 20,
+			"verdict": "TBD",
+			"rationale": "",
+			"name": "AI Voice Chatbot with ElevenLabs & OpenAI for Customer Service and Restaurants",
+			"triggerType": "manual",
+			"hasAI": true,
+			"nodeCount": 14,
+			"score": 87.44,
+			"source": "https://n8n.io/workflows/2846"
+		}
+	]
+}
diff --git a/packages/@n8n/workflow-sdk/examples/_coverage-report.json b/packages/@n8n/workflow-sdk/examples/_coverage-report.json
new file mode 100644
index 00000000000..98df51d44b6
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/examples/_coverage-report.json
@@ -0,0 +1,809 @@
+{
+	"generatedAt": "2026-05-07T13:26:57.543Z",
+	"total_prompts": 14,
+	"covered": 14,
+	"uncovered": 0,
+	"coverage": 1,
+	"target": 0.7,
+	"passed": true,
+	"results": [
+		{
+			"prompt_file": "airtable-split-to-slack.json",
+			"prompt": "Every hour, fetch all records from an Airtable table. Use the HTTP Request node to call GET https://api.airtable.com/v0/app123abc/Tasks with a Bearer token auth header — Airtable responds with a JSON ",
+			"keywords": [
+				"hour",
+				"records",
+				"airtable",
+				"table",
+				"app123abc",
+				"tasks",
+				"bearer",
+				"token",
+				"header",
+				"responds",
+				"json",
+				"object",
+				"shape",
+				"where",
+				"record",
+				"post",
+				"slack",
+				"channel",
+				"daily-tasks",
+				"containing",
+				"task",
+				"status",
+				"later",
+				"build",
+				"schedule",
+				"split"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "automate-3d-body-model-generation-from-images-using-sam-3d-g-11460",
+				"matches": 10,
+				"matched_keywords": [
+					"tasks",
+					"header",
+					"json",
+					"shape",
+					"where",
+					"post",
+					"channel",
+					"task",
+					"status",
+					"schedule"
+				]
+			}
+		},
+		{
+			"prompt_file": "contact-form-automation.json",
+			"prompt": "Create a workflow that handles contact form submissions via a webhook. It should send an auto-reply email to the person who submitted the form, notify my team on Telegram, and log each submission to G",
+			"keywords": [
+				"handles",
+				"contact",
+				"form",
+				"webhook",
+				"auto-reply",
+				"email",
+				"person",
+				"who",
+				"notify",
+				"team",
+				"telegram",
+				"log",
+				"google",
+				"sheets",
+				"documentid",
+				"1bximvs0xra5nfmdkvbdbzjgmuuqptlbs74ogve2upms",
+				"sheet",
+				"later",
+				"build",
+				"gmail",
+				"multi",
+				"action"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "lead-generation-system-google-maps-to-email-scraper-with-goo-5385",
+				"matches": 12,
+				"matched_keywords": [
+					"handles",
+					"contact",
+					"form",
+					"email",
+					"team",
+					"log",
+					"google",
+					"sheets",
+					"sheet",
+					"build",
+					"multi",
+					"action"
+				]
+			}
+		},
+		{
+			"prompt_file": "cross-team-linear-report.json",
+			"prompt": "Get all the Linear issues created in the last 2 weeks. Filter them for issues created for a different team than the one the creator is in. I have this team mapping to use: Alice (alice@company.com) be",
+			"keywords": [
+				"linear",
+				"issues",
+				"created",
+				"last",
+				"weeks",
+				"filter",
+				"different",
+				"team",
+				"than",
+				"creator",
+				"mapping",
+				"alice",
+				"company",
+				"belongs",
+				"both",
+				"frontend",
+				"bob",
+				"backend",
+				"carol",
+				"store",
+				"note",
+				"person",
+				"belong",
+				"multiple",
+				"teams",
+				"cross-team",
+				"issue",
+				"only",
+				"not",
+				"list",
+				"calculate",
+				"number",
+				"tickets",
+				"per",
+				"post",
+				"ordered",
+				"descending",
+				"slack",
+				"channel",
+				"called",
+				"cross-team-reports",
+				"later",
+				"build",
+				"schedule",
+				"processing"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 19,
+				"matched_keywords": [
+					"linear",
+					"issues",
+					"filter",
+					"different",
+					"team",
+					"company",
+					"note",
+					"multiple",
+					"teams",
+					"issue",
+					"only",
+					"not",
+					"list",
+					"calculate",
+					"number",
+					"per",
+					"channel",
+					"schedule",
+					"processing"
+				]
+			}
+		},
+		{
+			"prompt_file": "daily-slack-summary.json",
+			"prompt": "Every day, get the posts made in the past day on 3 different Slack channels: #general (C04GENERAL01), #engineering (C04ENGINEER1), and #product (C04PRODUCT01). Summarize them using AI, and post the su",
+			"keywords": [
+				"day",
+				"posts",
+				"made",
+				"past",
+				"different",
+				"slack",
+				"channels",
+				"general",
+				"c04general01",
+				"engineering",
+				"c04engineer1",
+				"product",
+				"c04product01",
+				"summarize",
+				"post",
+				"summary",
+				"daily-digest",
+				"c04dailydg01",
+				"later",
+				"build",
+				"schedule"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "ai-telegram-bot-agent-smart-assistant-content-summarizer-4457",
+				"matches": 9,
+				"matched_keywords": [
+					"day",
+					"made",
+					"different",
+					"product",
+					"summarize",
+					"post",
+					"summary",
+					"build",
+					"schedule"
+				]
+			}
+		},
+		{
+			"prompt_file": "form-to-hubspot.json",
+			"prompt": "Create a form that collects: name, email, company, and interest level (dropdown: starter, professional, enterprise). When submitted, create a new contact in HubSpot with firstname, lastname (split fro",
+			"keywords": [
+				"form",
+				"collects",
+				"email",
+				"company",
+				"interest",
+				"level",
+				"dropdown",
+				"starter",
+				"professional",
+				"enterprise",
+				"new",
+				"contact",
+				"hubspot",
+				"firstname",
+				"lastname",
+				"split",
+				"custom",
+				"property",
+				"confirmation",
+				"sendgrid",
+				"address",
+				"subject",
+				"reaching",
+				"body",
+				"mention",
+				"later",
+				"build",
+				"trigger",
+				"crm"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "scrape-google-maps-business-leads-with-apify-gpt-4-email-ext-10640",
+				"matches": 13,
+				"matched_keywords": [
+					"form",
+					"email",
+					"company",
+					"professional",
+					"contact",
+					"hubspot",
+					"split",
+					"custom",
+					"confirmation",
+					"address",
+					"build",
+					"trigger",
+					"crm"
+				]
+			}
+		},
+		{
+			"prompt_file": "github-notion-sync.json",
+			"prompt": "Every day, fetch all open GitHub issues from repository 'acme-corp/backend' that have the label 'bug'. For each issue, create a page in a Notion database (database ID: 'a1b2c3d4e5f6789012345678abcdef0",
+			"keywords": [
+				"day",
+				"open",
+				"github",
+				"issues",
+				"repository",
+				"acme-corp",
+				"backend",
+				"label",
+				"bug",
+				"issue",
+				"page",
+				"notion",
+				"database",
+				"a1b2c3d4e5f6789012345678abcdef01",
+				"properties",
+				"title",
+				"html",
+				"created",
+				"date",
+				"assignee",
+				"login",
+				"unassigned",
+				"status",
+				"directly",
+				"repos",
+				"labels",
+				"state",
+				"bearer",
+				"token",
+				"authorization",
+				"header",
+				"later",
+				"build",
+				"schedule",
+				"sync"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 11,
+				"matched_keywords": [
+					"day",
+					"open",
+					"issues",
+					"label",
+					"issue",
+					"page",
+					"database",
+					"date",
+					"labels",
+					"header",
+					"schedule"
+				]
+			}
+		},
+		{
+			"prompt_file": "linear-bq-leaderboard.json",
+			"prompt": "Every two weeks I want to check the amount of n8n usage and bug reporting that the team has done and produce a leaderboard that then gets posted to Slack (channel ID: D034WT7G4CW).\n\nHere are the users",
+			"keywords": [
+				"weeks",
+				"want",
+				"check",
+				"amount",
+				"n8n",
+				"usage",
+				"bug",
+				"reporting",
+				"team",
+				"produce",
+				"leaderboard",
+				"posted",
+				"slack",
+				"channel",
+				"d034wt7g4cw",
+				"here",
+				"users",
+				"david",
+				"roberts",
+				"arens",
+				"niklas",
+				"hatje",
+				"example",
+				"last",
+				"jonathan",
+				"clift",
+				"tickets",
+				"execs",
+				"hours",
+				"fabian",
+				"puehringer",
+				"tuukka",
+				"kantola",
+				"linear",
+				"created",
+				"manual",
+				"registered",
+				"accounts",
+				"ordered",
+				"number",
+				"desc",
+				"bugs",
+				"user",
+				"reported",
+				"query",
+				"issues",
+				"any",
+				"label",
+				"case-sensitive",
+				"matched",
+				"connect",
+				"bigquery",
+				"something",
+				"similar",
+				"following",
+				"settings",
+				"select",
+				"timestamp",
+				"start",
+				"cutoff",
+				"end",
+				"unnest",
+				"struct",
+				"string",
+				"exec",
+				"trunc",
+				"hour",
+				"instance",
+				"status",
+				"rudder",
+				"schema",
+				"finished",
+				"inner",
+				"join",
+				"cross",
+				"where",
+				"between",
+				"union",
+				"summary",
+				"count",
+				"distinct",
+				"instances",
+				"group",
+				"later",
+				"build",
+				"schedule"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 29,
+				"matched_keywords": [
+					"check",
+					"amount",
+					"n8n",
+					"reporting",
+					"team",
+					"channel",
+					"hours",
+					"linear",
+					"manual",
+					"accounts",
+					"number",
+					"desc",
+					"issues",
+					"any",
+					"label",
+					"connect",
+					"similar",
+					"settings",
+					"select",
+					"timestamp",
+					"end",
+					"struct",
+					"hour",
+					"instance",
+					"join",
+					"cross",
+					"count",
+					"group",
+					"schedule"
+				]
+			}
+		},
+		{
+			"prompt_file": "notification-router.json",
+			"prompt": "Create a workflow that receives webhook notifications with a JSON body containing 'level' (high, medium, or low), 'title', and 'message'. Route them based on level: high priority goes to Microsoft Tea",
+			"keywords": [
+				"receives",
+				"webhook",
+				"notifications",
+				"json",
+				"body",
+				"containing",
+				"level",
+				"high",
+				"medium",
+				"low",
+				"title",
+				"route",
+				"based",
+				"priority",
+				"goes",
+				"microsoft",
+				"teams",
+				"team",
+				"9b4c3a2f-1d8e-4f5b-a6c7-8e9f0b1d2c3a",
+				"channel",
+				"a1b2c3d4e5f6",
+				"thread",
+				"tacv2",
+				"slack",
+				"gmail",
+				"alerts",
+				"ourcompany",
+				"notification",
+				"include",
+				"payload",
+				"later",
+				"build",
+				"switch",
+				"routing"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 13,
+				"matched_keywords": [
+					"json",
+					"body",
+					"level",
+					"high",
+					"medium",
+					"low",
+					"based",
+					"microsoft",
+					"teams",
+					"team",
+					"channel",
+					"gmail",
+					"include"
+				]
+			}
+		},
+		{
+			"prompt_file": "rest-api-data-pipeline.json",
+			"prompt": "Fetch the latest posts from the JSONPlaceholder API (GET https://jsonplaceholder.typicode.com/posts). Filter out any posts where the title contains the word 'qui'. Then post a summary message to a Sla",
+			"keywords": [
+				"latest",
+				"posts",
+				"jsonplaceholder",
+				"typicode",
+				"filter",
+				"any",
+				"where",
+				"title",
+				"contains",
+				"word",
+				"qui",
+				"post",
+				"summary",
+				"slack",
+				"channel",
+				"called",
+				"api-digest",
+				"says",
+				"many",
+				"remain",
+				"lists",
+				"titles",
+				"later",
+				"build",
+				"transformation",
+				"schedule"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "scrape-linkedin-job-listings-for-hiring-signals-prospecting--3580",
+				"matches": 10,
+				"matched_keywords": [
+					"posts",
+					"filter",
+					"any",
+					"title",
+					"word",
+					"qui",
+					"post",
+					"lists",
+					"titles",
+					"build"
+				]
+			}
+		},
+		{
+			"prompt_file": "set-edit-fields-contract.json",
+			"prompt": "Every day, fetch one post from the JSONPlaceholder API (GET https://jsonplaceholder.typicode.com/posts/1). Then use an Edit Fields (Set) node, not a Code node, to add a field called caption from the p",
+			"keywords": [
+				"day",
+				"post",
+				"jsonplaceholder",
+				"typicode",
+				"posts",
+				"edit",
+				"not",
+				"code",
+				"called",
+				"caption",
+				"title",
+				"source",
+				"while",
+				"preserving",
+				"original",
+				"later",
+				"build",
+				"schedule",
+				"transformation"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "scrape-linkedin-job-listings-for-hiring-signals-prospecting--3580",
+				"matches": 8,
+				"matched_keywords": ["day", "post", "posts", "edit", "not", "code", "title", "build"]
+			}
+		},
+		{
+			"prompt_file": "telegram-chatbot-memory-session.json",
+			"prompt": "Build a Telegram chatbot workflow for a family assistant. It should receive Telegram messages, answer with an AI Agent using an OpenAI chat model, keep short-term conversation memory scoped separately",
+			"keywords": [
+				"build",
+				"telegram",
+				"chatbot",
+				"family",
+				"assistant",
+				"receive",
+				"answer",
+				"agent",
+				"openai",
+				"chat",
+				"model",
+				"keep",
+				"short-term",
+				"conversation",
+				"memory",
+				"scoped",
+				"separately",
+				"back",
+				"same",
+				"later",
+				"expressions"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "build-a-voice-ai-chatbot-with-elevenlabs-and-infranodus-know-4484",
+				"matches": 13,
+				"matched_keywords": [
+					"build",
+					"telegram",
+					"chatbot",
+					"receive",
+					"answer",
+					"agent",
+					"openai",
+					"chat",
+					"keep",
+					"conversation",
+					"memory",
+					"back",
+					"same"
+				]
+			}
+		},
+		{
+			"prompt_file": "weather-alert.json",
+			"prompt": "Every day at 8am, check the weather in Berlin using the OpenMeteo API and send me an email to david@thedavid.co.uk using the gmail node if it's going to rain",
+			"keywords": [
+				"day",
+				"8am",
+				"check",
+				"weather",
+				"berlin",
+				"openmeteo",
+				"email",
+				"david",
+				"thedavid",
+				"gmail",
+				"going",
+				"rain",
+				"build",
+				"schedule",
+				"conditional"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 7,
+				"matched_keywords": ["day", "check", "email", "gmail", "going", "rain", "schedule"]
+			}
+		},
+		{
+			"prompt_file": "weather-monitoring.json",
+			"prompt": "Every hour, check the current weather for London, New York, and Tokyo using the OpenWeatherMap API. Use 3 separate HTTP Request nodes, one per city. If any city has a temperature above 30°C, send a Te",
+			"keywords": [
+				"hour",
+				"check",
+				"current",
+				"weather",
+				"london",
+				"new",
+				"york",
+				"tokyo",
+				"openweathermap",
+				"separate",
+				"per",
+				"city",
+				"any",
+				"temperature",
+				"above",
+				"telegram",
+				"alert",
+				"chat",
+				"-1001234567890",
+				"listing",
+				"hot",
+				"cities",
+				"log",
+				"readings",
+				"airtable",
+				"table",
+				"base",
+				"appk2xgfgnoirl2gt",
+				"tbl8xk3np5mq7rs9w",
+				"columns",
+				"humidity",
+				"timestamp",
+				"later",
+				"build",
+				"schedule",
+				"conditional",
+				"multi"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 14,
+				"matched_keywords": [
+					"hour",
+					"check",
+					"current",
+					"new",
+					"per",
+					"city",
+					"any",
+					"chat",
+					"log",
+					"table",
+					"base",
+					"timestamp",
+					"schedule",
+					"multi"
+				]
+			}
+		},
+		{
+			"prompt_file": "workflow-data-table.json",
+			"prompt": "I want you to build a workflow that will read n8n workflow databases and extract certain information and then populate that information in a data table called 'workflows'.\n\nThe schema of the data tabl",
+			"keywords": [
+				"want",
+				"you",
+				"build",
+				"read",
+				"n8n",
+				"databases",
+				"extract",
+				"certain",
+				"information",
+				"populate",
+				"table",
+				"called",
+				"schema",
+				"follows",
+				"instanceid",
+				"workflowid",
+				"workflowname",
+				"tags",
+				"run",
+				"multiple",
+				"times",
+				"update",
+				"current",
+				"rows",
+				"rather",
+				"than",
+				"creating",
+				"dupes",
+				"instance",
+				"wonderman",
+				"users",
+				"cloud",
+				"later",
+				"schedule"
+			],
+			"matched": true,
+			"top_match": {
+				"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+				"matches": 15,
+				"matched_keywords": [
+					"you",
+					"read",
+					"n8n",
+					"extract",
+					"certain",
+					"information",
+					"populate",
+					"table",
+					"multiple",
+					"times",
+					"update",
+					"current",
+					"instance",
+					"cloud",
+					"schedule"
+				]
+			}
+		}
+	]
+}
diff --git a/packages/@n8n/workflow-sdk/examples/manifest.json b/packages/@n8n/workflow-sdk/examples/manifest.json
new file mode 100644
index 00000000000..ad7ca0d0403
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/examples/manifest.json
@@ -0,0 +1,3491 @@
+{
+	"generatedAt": "2026-05-07T14:34:49.852Z",
+	"workflows": [
+		{
+			"id": 6270,
+			"slug": "build-your-first-ai-agent-6270",
+			"name": "Build Your First AI Agent",
+			"description": "## How it works\n\nThis template launches your very first **AI Agent** —an AI-powered chatbot that can do more than just talk— it can take action using tools.\n\nThink of an AI Agent as a smart assistant, and the tools are the apps on its phone. By connecting it to other nodes, you give your agent the ability to interact with real-world data and services, like checking the weather, fetching news, or even sending emails on your behalf.\n\nThis workflow is designed to be the perfect starting point:\n*   **The Chat Interface:** A `Chat Trigger` node provides a simple, clean interface for you to talk to your agent.\n*   **The Brains:** The `AI Agent` node receives your messages, intelligently decides which tool to use (if any), and formulates a helpful response. Its personality and instructions are fully customizable in the \"System Message\".\n*   **The Language Model:** It uses **Google Gemini** to power its reasoning and conversation skills.\n*   **The Tools:** It comes pre-equipped with two tools to demonstrate its capabilities:\n    1.  **Get Weather:** Fetches real-time weather forecasts.\n    2.  **Get News:** Reads any RSS feed to get the latest headlines.\n*   **The Memory:** A `Conversation Memory` node allows the agent to remember the last few messages, enabling natural, follow-up conversations.\n\n### Set up steps\n\n**Setup time: ~2 minutes**\n\nYou only need one thing to get started: a free Google AI API key.\n\n1.  **Get Your Google AI API Key:**\n    *   Visit Google AI Studio at [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey).\n    *   Click **\"Create API key in new project\"** and copy the key that appears.\n\n2.  **Add Your Credential in n8n:**\n    *   On the workflow canvas, go to the **`Connect your model`** (Google Gemini) node.\n    *   Click the **Credential** dropdown and select **`+ Create New Credential`**.\n    *   Paste your API key into the **API Key** field and click **Save**.\n\n3.  **Start Chatting!**\n    *   Go to the **`Example Chat`** node.\n    *   Click the **\"Open Chat\"** button in its parameter panel.\n    *   Try asking it one of the example questions, like: *\"What's the weather in Paris?\"* or *\"Get me the latest tech news.\"*\n\nThat's it! You now have a fully functional AI Agent. Try adding more tools (like Gmail or Google Calendar) to make it even more powerful.",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.rssFeedReadTool",
+				"n8n-nodes-base.httpRequestTool",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:langchain"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 95,
+			"scoreBreakdown": {
+				"traction": 1,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/6270",
+			"author": "lucaspeyrin",
+			"success": true
+		},
+		{
+			"id": 8237,
+			"slug": "personal-life-manager-with-telegram-google-services-voice-en-8237",
+			"name": "Personal Life Manager with Telegram, Google Services & Voice-Enabled AI",
+			"description": "**How it works:**\nThis project teaches you to create a personal AI assistant named Jackie that operates through Telegram. Jackie can summarize unread emails, check calendar events, manage Google Tasks, and handle both voice and text interactions. The assistant provides a comprehensive digital life management solution accessible via Telegram messaging.\n\n**Key Features:** \n- Supports hands-free voice interaction\n- Maintains conversation memory\n- Integrates with major Google services\n- Provides personalized assistance for email management, scheduling, and task organization\n\n**Step-by-step:**\nTelegram Trigger: \nThe workflow starts with a Telegram trigger that listens for incoming message events. The system determines if the incoming message is voice or text input.\n\nVoice Processing: \nIf a voice message is received, the workflow retrieves the voice file from Telegram and uses OpenAI's transcription API to convert speech to text.\n\nAI Assistant: The processed text (whether original text or transcribed voice) is passed to Jackie, the AI assistant powered by OpenRouter's language model.\n\n**Tools Integration:** \nJackie is equipped with several productivity tools:\n\nGet Email: Uses Gmail API to fetch unread emails from the inbox with sender, date, subject, and summary information\n\nGoogle Calendar: Retrieves calendar events for specified dates, filtering out irrelevant future events\n\nGoogle Tasks: Both creates new tasks and retrieves existing tasks from Google Tasks lists\n\n**API Keys Required:**\n- Telegram Bot API: Create a bot via @BotFather on Telegram to get your bot token\n- OpenAI API: Required for voice-to-text transcription \n- OpenRouter API: Powers the AI language model responses \n- Google OAuth2: Needed for Gmail, Google Calendar, and Google Tasks integration\n\n\n**Response Generation:**\nThe AI formulates intelligent responses based on the gathered information, current date context, and conversation history, then sends the response back to the user via Telegram in Markdown format.\n",
+			"nodes": [
+				"n8n-nodes-base.googleCalendarTool",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.gmailTool",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"n8n-nodes-base.googleTasksTool",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"@n8n/n8n-nodes-langchain.agent"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:langchain"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 90.95,
+			"scoreBreakdown": {
+				"traction": 0.851,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.786
+			},
+			"source": "https://n8n.io/workflows/8237",
+			"author": "derekcheungsa",
+			"success": true
+		},
+		{
+			"id": 2753,
+			"slug": "rag-chatbot-for-company-documents-using-google-drive-and-gem-2753",
+			"name": "RAG Chatbot for Company Documents using Google Drive and Gemini",
+			"description": "This workflow implements a Retrieval Augmented Generation (RAG) chatbot that answers employee questions based on company documents stored in Google Drive. It automatically indexes new or updated documents in a Pinecone vector database, allowing the chatbot to provide accurate and up-to-date information. The workflow uses Google's Gemini AI for both embeddings and response generation.\n\n## How it works\nThe workflow uses two `Google Drive Trigger` nodes: one for detecting new files added to a specified Google Drive folder, and another for detecting file updates in that same folder.\n1. Automated Indexing: When a new or updated document is detected\n2. The `Google Drive` node downloads the file.\n3. The `Default Data Loader` node loads the document content.\n4. The `Recursive Character Text Splitter` node breaks the document into smaller text chunks.\n5. The Embeddings Google Gemini node generates embeddings for each text chunk using the text-embedding-004 model.\n6. The `Pinecone Vector Store` node indexes the text chunks and their embeddings in a specified Pinecone index.\n7.The Chat Trigger node receives user questions through a chat interface. The user's question is passed to an AI Agent node.\n8. The `AI Agent` node uses a `Vector Store Tool` node, linked to a Pinecone Vector Store node in query mode, to retrieve relevant text chunks from Pinecone based on the user's question.\n9. The AI Agent sends the retrieved information and the user's question to the Google Gemini Chat Model (gemini-pro).\n10. The `Google Gemini Chat Model` generates a comprehensive and informative answer based on the retrieved documents.\n11. A `Window Buffer Memory` node connected to the AI Agent provides short-term memory, allowing for more natural and context-aware conversations.\n\n## Set up steps\n\n1. Google Cloud Project and Vertex AI API:\n* Create a Google Cloud project.\n* Enable the Vertex AI API for your project.\n2. Google AI API Key:\n* Obtain a Google AI API key from Google AI Studio.\n3. Pinecone Account:\n* Create a free account on the Pinecone website.\nObtain your API key from your Pinecone dashboard.\n* Create an index named company-files in your Pinecone project.\n4. Google Drive:\n* Create a dedicated folder in your Google Drive where company documents will be stored.\n5. Credentials in n8n: Configure credentials in your n8n environment for:\n* Google Drive OAuth2\n* Google Gemini(PaLM) Api (using your Google AI API key)\n* Pinecone API (using your Pinecone API key)\n5. Import the Workflow:\n* Import this workflow into your n8n instance.\n6. Configure the Workflow:\n* Update both Google Drive Trigger nodes to watch the specific folder you created in your Google Drive.\n* Configure the Pinecone Vector Store nodes to use your company-files index.",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.vectorStorePinecone",
+				"@n8n/n8n-nodes-langchain.embeddingsGoogleGemini",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.toolVectorStore",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleDriveTrigger",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini"
+			],
+			"tags": ["trigger:other", "ai", "integration:langchain"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 90.35,
+			"scoreBreakdown": {
+				"traction": 0.834,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.733
+			},
+			"source": "https://n8n.io/workflows/2753",
+			"author": "mihailtd",
+			"success": true
+		},
+		{
+			"id": 4846,
+			"slug": "generate-ai-videos-with-google-veo3-save-to-google-drive-and-4846",
+			"name": "Generate AI Videos with Google Veo3, Save to Google Drive and Upload to YouTube",
+			"description": "This workflow allows users to **generate AI videos** using **Google Veo3**, save them to **Google Drive**, generate optimized YouTube titles with GPT-4o, and **automatically upload them to YouTube** with [Upload-Post](https://www.upload-post.com/?linkId=lp_144414&sourceId=n3witalia&tenantId=upload-post-app). The entire process is triggered from a Google Sheet that acts as the central interface for input and output.\n\nIT automates video creation, uploading, and tracking, ensuring seamless integration between Google Sheets, Google Drive, Google Veo3, and YouTube.\n\n\n---\n\n### Benefits of this Workflow\n\n* **💡 No Code Interface**: Trigger and control the video production pipeline from a simple Google Sheet.\n* **⚙️ Full Automation**: Once set up, the entire video generation and publishing process runs hands-free.\n* **🧠 AI-Powered Creativity**:\n\n  * Generates engaging YouTube titles using GPT-4o.\n  * Leverages advanced generative video AI from Google Veo3.\n* **📁 Cloud Storage & Backup**: Stores all generated videos on Google Drive for safekeeping.\n* **📈 YouTube Ready**: Automatically uploads to YouTube with correct metadata, saving time and boosting visibility.\n* **🧪 Scalable**: Designed to process multiple video prompts by looping through new entries in Google Sheets.\n* **🔒 API-First**: Utilizes secure API-based communication for all services.\n\n---\n\n### **How It Works**  \n1. **Trigger**: The workflow can be started manually (\"When clicking ‘Test workflow’\") or scheduled (\"Schedule Trigger\") to run at regular intervals (e.g., every 5 minutes).  \n2. **Fetch Data**: The \"Get new video\" node retrieves unfilled video requests from a Google Sheet (rows where the \"VIDEO\" column is empty).  \n3. **Video Creation**:  \n   - The \"Set data\" node formats the prompt and duration from the Google Sheet.  \n   - The \"Create Video\" node sends a request to the Fal.run API (Google Veo3) to generate a video based on the prompt.  \n4. **Status Check**:  \n   - The \"Wait 60 sec.\" node pauses execution for 60 seconds.  \n   - The \"Get status\" node checks the video generation status. If the status is \"COMPLETED,\" the workflow proceeds; otherwise, it waits again.  \n5. **Video Processing**:  \n   - The \"Get Url Video\" node fetches the video URL.  \n   - The \"Generate title\" node uses OpenAI (GPT-4.1) to create an SEO-optimized YouTube title.  \n   - The \"Get File Video\" node downloads the video file.  \n6. **Upload & Update**:  \n   - The \"Upload Video\" node saves the video to Google Drive.  \n   - The \"HTTP Request\" node uploads the video to YouTube via the Upload-Post API.  \n   - The \"Update Youtube URL\" and \"Update result\" nodes update the Google Sheet with the video URL and YouTube link.  \n\n---\n\n### **Set Up Steps**  \n1. **Google Sheet Setup**:  \n   - Create a Google Sheet with columns: **PROMPT**, **DURATION**, **VIDEO**, and **YOUTUBE_URL**.  \n   - Share the Sheet link in the \"Get new video\" node.  \n\n2. **API Keys**:  \n   - Obtain a Fal.run API key (for Veo3) and set it in the \"Create Video\" node (Header: `Authorization: Key YOURAPIKEY`).  \n   - Get an Upload-Post API key (for YouTube uploads) and configure the \"HTTP Request\" node (Header: `Authorization: Apikey YOUR_API_KEY`).  \n\n3. **YouTube Upload Configuration**:  \n   - Replace `YOUR_USERNAME` in the \"HTTP Request\" node with your Upload-Post profile name.  \n\n4. **Schedule Trigger**:  \n   - Configure the \"Schedule Trigger\" node to run periodically (e.g., every 5 minutes).  \n\n---\n\n👉 [Subscribe to my new **YouTube channel**](https://youtube.com/@n3witalia). Here I’ll share videos and Shorts with practical tutorials and **FREE templates for n8n**.\n\n[![image](https://n3wstorage.b-cdn.net/n3witalia/youtube-n8n-cover.jpg)](https://youtube.com/@n3witalia)\n\n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/).",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.openAi"
+			],
+			"tags": ["trigger:manual", "ai", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 90.19,
+			"scoreBreakdown": {
+				"traction": 0.859,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.6
+			},
+			"source": "https://n8n.io/workflows/4846",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4352,
+			"slug": "ai-powered-multi-social-media-post-automation-google-trends--4352",
+			"name": "AI-Powered Multi-Social Media Post Automation: Google Trends & Perplexity AI ",
+			"description": "![Screenshot 20250524 013951.png](fileId:1366)\n## Overview\nThis comprehensive n8n workflow automatically transforms trending Google search queries into engaging LinkedIn posts using AI. The system runs autonomously, discovering viral topics, researching content, and publishing professionally formatted posts to grow your social media presence.\n\n## Workflow Description\n**Automate your entire social media content pipeline** - from trend discovery to publication. This workflow monitors Google Trends, selects high-potential topics, creates human-like content using advanced AI, and publishes across multiple social platforms with built-in tracking.\n\n## Key Features\n- **Automated Trend Discovery**: Pulls trending topics from Google Trends API with customizable filters\n- **Intelligent Topic Selection**: AI chooses the most relevant trending topic for your niche\n- **Multi-AI Content Generation**: Combines Perplexity for research and OpenAI for content curation\n- **Human-Like Writing**: Advanced prompts eliminate AI detection markers\n- **LinkedIn Optimization**: Proper formatting with Unicode characters, emojis, and engagement hooks\n- **Multi-Platform Support**: Ready for LinkedIn, Twitter/X, and Facebook posting\n- **Automated Scheduling**: Configurable posting times (default: 6 AM & 6 PM daily)\n- **Performance Tracking**: Automatic logging to Google Sheets with timestamps and metrics\n- **Error Handling**: Built-in delays and retry mechanisms for API stability\n\n## Technical Implementation\n\n### Workflow Architecture\n1. **Schedule Trigger**: Automated execution at specified intervals\n2. **Google Trends API**: Fetches trending search queries with geographical filtering\n3. **Data Processing**: JavaScript code node filters high-volume keywords (30+ search volume)\n4. **Topic Selection**: OpenAI GPT-3.5 evaluates and selects optimal trending topic\n5. **Content Research**: Perplexity AI researches selected topic for current information\n6. **Content Generation**: Advanced prompt engineering creates LinkedIn-optimized posts\n7. **Content Distribution**: Multi-platform posting with platform-specific formatting\n8. **Analytics Tracking**: Google Sheets integration for performance monitoring\n\n### Node Breakdown\n- **Schedule Trigger**: Configurable timing for automated execution\n- **HTTP Request (Google Trends)**: SerpAPI integration for trend data\n- **Set Node**: Structures trending data for processing\n- **Code Node**: JavaScript filtering for high-volume keywords\n- **OpenAI Node**: Intelligent topic selection based on relevance and trend strength\n- **HTTP Request (Perplexity)**: Advanced AI research with anti-detection prompts\n- **Wait Node**: Rate limiting and API respect\n- **Split Out**: Prepares content for multi-platform distribution\n- **LinkedIn Node**: Authenticated posting with community management\n- **Google Sheets Node**: Automated tracking and analytics\n- **Social Media Nodes**: Twitter/X, LinkedIn and Facebook ready for activation\n\n## Use Cases\n- **Content Creators**: Maintain consistent posting schedules with trending content\n- **Marketing Agencies**: Scale content creation across multiple client accounts\n- **Business Development**: Build thought leadership with timely industry insights\n- **Personal Branding**: Establish authority by commenting on trending topics\n- **SEO Professionals**: Create content around high-search-volume keywords\n\n## Configuration Requirements\n\n### API Integrations\n- **SerpAPI**: Google Trends data access\n- **Perplexity AI**: Advanced content research capabilities\n- **OpenAI**: Content curation and topic selection\n- **LinkedIn Community Management API**: Professional posting access\n- **Google Sheets API**: Analytics and tracking\n\n### Authentication Setup\n- LinkedIn OAuth2 community management credentials\n- Google Sheets OAuth2 integration\n- HTTP header authentication for AI services\n\n## Customization Options\n- **Industry Targeting**: Modify prompts for specific business verticals\n- **Posting Schedule**: Adjust timing based on audience activity\n- **Content Tone**: Customize voice and style through prompt engineering\n- **Platform Selection**: Enable/disable specific social media channels\n- **Trend Filtering**: Adjust search volume thresholds and geographic targeting\n- **Content Length**: Modify character limits for different platforms\n\n## Advanced Features\n- **Anti-AI Detection**: Sophisticated prompts create human-like content\n- **Rate Limit Management**: Built-in delays prevent API throttling\n- **Error Recovery**: Robust error handling with retry mechanisms\n- **Content Deduplication**: Prevents posting duplicate content\n- **Engagement Optimization**: LinkedIn-specific formatting for maximum reach\n\n## Performance Metrics\n- **Time Savings**: Eliminates 10+ hours of weekly content creation\n- **Consistency**: Maintains regular posting schedule without manual intervention\n- **Relevance**: Content always based on current trending topics\n- **Engagement**: Optimized formatting increases social media interaction\n- **Scalability**: Single workflow manages multiple platform posting\n\n## Installation Notes\n- Import JSON workflow file into n8n instance\n- Configure all required API credentials\n- Set up [Google Sheets](Google Sheets) tracking document\n- Test workflow execution with manual trigger\n- Enable schedule trigger for automated operation\n\n## Best Practices\n- Monitor API usage to stay within rate limits\n- Regularly update prompts based on content performance\n- Review and adjust trending topic filters for your niche\n- Maintain backup of workflow configuration\n- Test content output before enabling automation\n\n## Support & Updates\n- Comprehensive setup documentation included\n- Configuration troubleshooting guide provided\n- Regular workflow updates for API changes\n- Community support through n8n forums\n\n## Tags\n`social-media` `content-automation` `linkedin` `ai-generation` `google-trends` `perplexity` `openai` `marketing` `trend-analysis` `content-creation`\n\n## Compatibility\n- n8n Version: 1.0+\n- Node Requirements: Standard n8n installation\n- External Dependencies: API access to listed services\n- Hosting: Compatible with cloud and self-hosted n8n instances",
+			"nodes": [
+				"n8n-nodes-base.twitter",
+				"n8n-nodes-base.facebookGraphApi",
+				"n8n-nodes-base.linkedIn",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.wait"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:httpRequest"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 89.9,
+			"scoreBreakdown": {
+				"traction": 0.766,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.917
+			},
+			"source": "https://n8n.io/workflows/4352",
+			"author": "dominixai",
+			"success": true
+		},
+		{
+			"id": 5148,
+			"slug": "local-chatbot-with-retrieval-augmented-generation-rag-5148",
+			"name": "Local Chatbot with Retrieval Augmented Generation (RAG)",
+			"description": "## Build a 100% local RAG with n8n, Ollama and Qdrant. This agent uses a semantic database (Qdrant) to answer questions about PDF files.\n\n## Tutorial\n![thumbnail.png](fileId:1589)\n[Click here to view the YouTube Tutorial](https://youtu.be/maZ_fF57yhE)\n\n## How it works\nBuild a chatbot that answers based on documents you provide it (Retrieval Augmented Generation). You can upload as many PDF files as you want to the Qdrant database. The chatbot will use its retrieval tool to fetch the chunks and use them to answer questions.\n\n## Installation\n1. Install n8n + Ollama + Qdrant using the [Self-hosted AI starter kit](https://github.com/n8n-io/self-hosted-ai-starter-kit)\n2. Make sure to install Llama 3.2 and mxbai-embed-large as embeddings model.\n\n## How to use it\n1. First run the \"Data Ingestion\" part and upload as many PDF files as you want\n2. Run the Chatbot and start asking questions about the documents you uploaded\n",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"@n8n/n8n-nodes-langchain.vectorStoreQdrant",
+				"@n8n/n8n-nodes-langchain.embeddingsOllama",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatOllama",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:langchain"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 89.7,
+			"scoreBreakdown": {
+				"traction": 0.781,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.818
+			},
+			"source": "https://n8n.io/workflows/5148",
+			"author": "thomasjanssen-tech",
+			"success": true
+		},
+		{
+			"id": 4966,
+			"slug": "customer-support-whatsapp-bot-with-google-docs-knowledge-bas-4966",
+			"name": "Customer Support WhatsApp Bot with Google Docs Knowledge Base and Gemini AI",
+			"description": "* Document-Aware WhatsApp AI Bot for Customer Support\n\n* Google Docs-Powered WhatsApp Support Agent\n\n* 24/7 WhatsApp AI Assistant with Live Knowledge from Google Docs\n\n# 📝Description Template\n\n## Smart WhatsApp AI Assistant Using Google Docs\n\nHelp customers instantly on WhatsApp using a smart AI assistant that reads your company’s internal knowledge from a Google Doc in real time. Built for clubs, restaurants, agencies, or any business where clients ask questions based on a policy, FAQ, or services document.\n\n# ⚙️ How it works\n\n- Users send free-form questions to your WhatsApp Business number (e.g. “What are the gym rules?” or “Are you open today?”)\n\n- The bot automatically reads your company’s internal Google Doc (policy, schedule, etc.)\n\n- It merges the document content with today’s date and the user’s question to craft a custom AI prompt\n\n- The AI (Gemini or ChatGPT) then replies back on WhatsApp using natural, helpful language\n\n- All conversations are logged to Google Sheets for reporting or audit\n\n&gt; 💡Bonus: The AI even understands dates inside the document and compares them to today’s date — e.g. if your document says “Closed May 25 for 30 days,” it will say “We're currently closed until June 24.\n\n# 🧰 Set up steps\n\n1. Connect your WhatsApp Cloud API account (Meta)\n\n2. Add your Google account and grant access to the Doc containing your company info\n\n3. Choose your AI model (ChatGPT/OpenAI or Gemini)\n\n4. Paste your document ID into the Google Docs node\n\n\n\n5. Connect your WhatsApp webhook to Meta (only takes 5 minutes)\n\n6. Done — start receiving and answering customer questions!\n\n&gt; 📄 Works best with free-tier OpenAI/Gemini, Google Docs, and Meta's Cloud API (no phone required). Everything is modular, extensible, and low-code.\n\n# 🔄 Customization Tips\n\n* Change the Google Doc anytime to update answers — no retraining needed\n\n* Add your logo and business name in the AI agent’s “System Prompt”\n\n* Add fallback routes like “Escalate to human” if the bot can't help\n\n* Clone for multiple brands by duplicating the workflow and swapping in new docs\n\n\n🤝 Need Help Setting It Up?\n\nIf you'd like help connecting your WhatsApp Business API, setting up Google Docs access, or customizing this AI assistant for your business or clients…\n\n📩 I offer setup, branding, and customization services:\n\n\n\n\n\nWhatsApp Cloud API setup & verification\n\n\n\nGoogle OAuth & Doc structure guidance\n\n\n\nAI model configuration (OpenAI / Gemini)\n\n\n\nBranding & prompt tone customization\n\n\n\nLogging, reporting, and escalation logic\n\nJust send a message via:\n\n\n\n\n\nEmail: tharwat.elsayed2000@gmail.com\n\n\n\nWhatsApp: +20 106 180 3236",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.whatsApp",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"n8n-nodes-base.whatsAppTrigger",
+				"n8n-nodes-base.aiTransform",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.dateTime",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleDocs",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow"
+			],
+			"tags": ["trigger:other", "ai", "integration:langchain"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 89.7,
+			"scoreBreakdown": {
+				"traction": 0.774,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.846
+			},
+			"source": "https://n8n.io/workflows/4966",
+			"author": "tharwatelsayed",
+			"success": true
+		},
+		{
+			"id": 5626,
+			"slug": "free-ai-image-generator-n8n-automation-workflow-with-gemini--5626",
+			"name": "Free AI Image Generator - n8n Automation Workflow with Gemini/ChatGPT",
+			"description": "### This n8n template demonstrates how to use AI to generate custom images from scratch - fully automated, prompt-driven, and ready to deploy at scale.\n\nUse cases are many: You can use it for marketing visuals, character art, digital posters, storyboards, or even daily image generation for your personal purposes.\n\n## How It Works\n- The flow is triggered by a chat message in N8N or via Telegram. The default image size is 1080 x 1920 pixels. To use a different size, update the values in the **“Fields - Set Values”** node before triggering the workflow.\n- The input is parsed into a clean, structured prompt using a multi-step transformation process.\n- Our AI Agent sends the final prompt to Google Gemini’s image model for generation (you can also integrate with OpenAI or other chat models).\n- The raw image data created by the AI Agent will be run through a number of codes to make sure it's feasible for your preview if needed and downloading.\n- Then, we use an HTTP node to fetch the result so you can preview the image.\n- You can send it back to the chat message in N8N or Telegram, or save it locally to your disk.\n\n## How To Use\n- Download the workflow package.\n- Import the package into your N8N interface.\n- Set up the credentials in the following nodes for tool access and usability: **\"Telegram Trigger\"**; **\"AI Agent - Create Image From Prompt\"**; **\"Telegram Response\"** or **\"Save Image To Disk\"** (based on your wish).\n- Activate the **\"Telegram Response\"** OR **\"Save Image To Disk\"** node to specify where you want to save your image later.\n- Open the chat interface (via N8N or Telegram).\n- Type your image prompt or detailed descriptions and send.\n- Wait for the process to run and finish in a few seconds.\n- Check the result in your desired saving location.\n\n## Requirements\n- Google Gemini account with image generation access.\n- Telegram bot access and chat setup (optional).\n- Connection to local storage (optional).\n\n## How To Customize\n- We’re setting the default image size to 1080 x 1920 pixels and the default image model to \"flux\". You can customize both of these values in the **“Fields – Set Values”** node. Supported image model options include: \"flux\", \"kontext\", \"turbo\", and \"gptimage\".\n- In the **“AI Agent – Create Image From Prompt”** node, you can also change the AI chat model. By default, it uses Google Gemini, but you can easily replace it with OpenAI ChatGPT, Microsoft AI Copilot, or any other compatible provider.\n\n## Need Help?\nJoin our community on different platforms for support, inspiration and tips from others.\n\nWebsite: https://www.agentcircle.ai/\nEtsy: https://www.etsy.com/shop/AgentCircle\nGumroad: http://agentcircle.gumroad.com/\nDiscord Global: https://discord.gg/d8SkCzKwnP\nFB Page Global: https://www.facebook.com/agentcircle/\nFB Group Global: https://www.facebook.com/groups/aiagentcircle/\nX: https://x.com/agent_circle\nYouTube: https://www.youtube.com/@agentcircle\nLinkedIn: https://www.linkedin.com/company/agentcircle",
+			"nodes": [
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.telegramTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.readWriteFile"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:code"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 89.61,
+			"scoreBreakdown": {
+				"traction": 0.776,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.818
+			},
+			"source": "https://n8n.io/workflows/5626",
+			"author": "agentcircle",
+			"success": true
+		},
+		{
+			"id": 5338,
+			"slug": "generate-ai-viral-videos-with-seedance-and-upload-to-tiktok--5338",
+			"name": "Generate AI Viral Videos with Seedance and Upload to TikTok, YouTube & Instagram",
+			"description": "![Workflow Screenshot](https://www.dr-firas.com/seedanceII.png)\n\n# Generate AI videos with Seedance & Blotato, upload to TikTok, YouTube & Instagram\n\n### Who is this for?\n\nThis template is ideal for creators, content marketers, social media managers, and AI enthusiasts who want to automate the production of short-form, visually captivating videos for platforms like TikTok, YouTube Shorts, and Instagram Reels — all without manual editing or publishing.\n\n### What problem is this workflow solving?\n\nCreating engaging videos requires:\n- Generating creative ideas  \n- Writing detailed scene prompts  \n- Producing realistic video clips and sound effects  \n- Editing and stitching the final video  \n- Publishing across multiple platforms  \n\nThis workflow automates the entire process, saving hours of manual work and ensuring consistent, AI-driven content output ready for social distribution.\n\n### What this workflow does\n\nThis end-to-end AI video automation workflow:\n\n1. **Generates a creative idea** using OpenAI and LangChain  \n2. **Creates detailed video prompts** with Seedance AI  \n3. **Generates video clips** via Wavespeed AI  \n4. **Generates sound effects** with Fal AI  \n5. **Stitches the final video** using Fal AI’s ffmpeg API  \n6. **Logs metadata and video links** to Google Sheets  \n7. **Uploads the video to Blotato**  \n8. **Auto-publishes to TikTok, YouTube, Instagram, and other platforms**\n\n### Setup\n\n1. Add your **OpenAI API key** in the LLM nodes  \n2. Set up **Seedance and Wavespeed AI credentials** for video prompt and clip generation  \n3. Add your **Fal AI API key** for sound and stitching steps  \n4. Connect your **Google Sheets account** for tracking ideas and outputs  \n5. Set your **Blotato API key** and fill in the platform account IDs in the `Assign Social Media IDs` node  \n6. Adjust the **Schedule Trigger** to control when the automation runs  \n\n### How to customize this workflow to your needs\n\n- **Change the AI prompts** to target your niche (e.g., ASMR, product videos, humor)  \n- **Add a Telegram or Slack step** for video preview before publishing  \n- **Tweak scene structure** or video duration to match your style  \n- **Disable platforms** you don’t want by turning off specific HTTP Request nodes  \n- **Edit the sound generation prompts** for different moods or effects  \n\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/Generate-AI-Videos-with-Seedance-Blotato-and-Upload-to-TikTok-YouTube-Instagram-version-II-21d3d6550fd980218096d84f31bfae2d?source=copy_link)\n\n---\n\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https:/https://www.youtube.com/@DRFIRASS)",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.scheduleTrigger",
+				"@n8n/n8n-nodes-langchain.toolThink",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@blotato/n8n-nodes-blotato.blotato",
+				"n8n-nodes-base.merge"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:blotato"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 89.35,
+			"scoreBreakdown": {
+				"traction": 0.887,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.324
+			},
+			"source": "https://n8n.io/workflows/5338",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 4827,
+			"slug": "ai-powered-whatsapp-chatbot-for-text-voice-images-and-pdf-wi-4827",
+			"name": "AI-Powered WhatsApp Chatbot for Text, Voice, Images, and PDF with RAG",
+			"description": "### Who is this for?\nThis template is designed for internal support teams, product specialists, and knowledge managers in technology companies who want to automate ingestion of product documentation and enable AI-driven, retrieval-augmented question answering via WhatsApp.\n\n### What problem is this workflow solving?\nSupport agents often spend too much time manually searching through lengthy documentation, leading to inconsistent or delayed answers. This solution automates importing, chunking, and indexing product manuals, then uses retrieval-augmented generation (RAG) to answer user queries accurately and quickly with AI via WhatsApp messaging.\n\n### What these workflows do\n\n#### Workflow 1: Document Ingestion & Indexing\n\n- Manually triggered to import product documentation from Google Docs.\n- Automatically splits large documents into chunks for efficient searching.\n- Generates vector embeddings for each chunk using OpenAI embeddings.\n- Inserts the embedded chunks and metadata into a MongoDB Atlas vector store, enabling fast semantic search.\n\n#### Workflow 2: AI-Powered Query & Response via WhatsApp\n\n- Listens for incoming WhatsApp user messages, supporting various types:\n\t- Text messages: Plain text queries from users.\n\t- Audio messages: Voice notes transcribed into text for processing.\n\t- Image messages: Photos or screenshots analyzed to provide contextual answers.\n\t- Document messages: PDFs, spreadsheets, or other files parsed for relevant content.\n- Converts incoming queries to vector embeddings and performs similarity search on the MongoDB vector store.\n- Uses OpenAI’s GPT-4o-mini model with retrieval-augmented generation to produce concise, context-aware answers.\n- Maintains conversation context across multiple turns using a memory buffer node.\n- Routes different message types to appropriate processing nodes to maximize answer quality.\n\n### Setup\n\n#### Setting up vector embeddings\n\n1. Authenticate Google Docs and connect your Google Docs URL containing the product documentation you want to index.\n2. Authenticate MongoDB Atlas and connect the collection where you want to store the vector embeddings. Create a search index on this collection to support vector similarity queries.\n3. Ensure the index name matches the one configured in n8n (data_index).\n4. See the example MongoDB search index template below for reference.\n\n#### Setting up chat\n\n1. Authenticate the WhatsApp node with your Meta account credentials to enable message receiving and sending.\n2. Connect the MongoDB collection containing embedded product documentation to the MongoDB Vector Search node used for similarity queries.\n3. Set up the system prompt in the Knowledge Base Agent node to reflect your company’s tone, answering style, and any business rules, ensuring it references the connected MongoDB collection for context retrieval.\n\n### Make sure\n\nBoth MongoDB nodes (in ingestion and chat workflows) are connected to the same collection with:\n\nAn embedding field storing vector data,\n\nRelevant metadata fields (e.g., document ID, source), and\n\nThe same vector index name configured (e.g., data_index).\n\n### Search Index Example:\n\n{\n  \"mappings\": {\n    \"dynamic\": false,\n    \"fields\": {\n      \"_id\": { \"type\": \"string\" },\n      \"text\": { \"type\": \"string\" },\n      \"embedding\": {\n        \"type\": \"knnVector\",\n        \"dimensions\": 1536,\n        \"similarity\": \"cosine\"\n      },\n      \"source\": { \"type\": \"string\" },\n      \"doc_id\": { \"type\": \"string\" }\n    }\n  }\n}",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"n8n-nodes-base.manualTrigger",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.vectorStoreMongoDBAtlas",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter",
+				"n8n-nodes-base.googleDocs",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.whatsAppTrigger",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.whatsApp",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.switch"
+			],
+			"tags": ["trigger:manual", "ai", "integration:langchain"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 89.26,
+			"scoreBreakdown": {
+				"traction": 0.83,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.531
+			},
+			"source": "https://n8n.io/workflows/4827",
+			"author": "thomasgpt",
+			"success": true
+		},
+		{
+			"id": 5110,
+			"slug": "create-upload-ai-generated-asmr-youtube-shorts-with-seedance-5110",
+			"name": "Create & Upload AI-Generated ASMR YouTube Shorts with Seedance, Fal AI, and GPT-4",
+			"description": "![Workflow_Screenshot.png](fileId:1559)\n\n//ASMR AI Workflow \n### Who is this for?\n\nContent Creators, YouTube Automation Enthusiasts, and AI Hobbyists looking to autonomously generate and publish unique, satisfying ASMR-style YouTube Shorts without manual effort.\n\n### What problem does this solve?\n\nThis workflow solves the creative bottleneck and time-consuming nature of daily content creation. It fully automates the entire production pipeline, from brainstorming trendy ideas to publishing a finished video, turning your n8n instance into a 24/7 content factory.\n\n### What this workflow does\n\n**1. Two-Stage AI Ideation & Planning:**\n*   Uses an initial AI agent to brainstorm a short, viral ASMR concept based on current trends.\n*   A second \"Planning\" AI agent then takes this concept and expands it into a detailed, structured production plan, complete with a viral-optimized caption, hashtags, and descriptions for the environment and sound.\n\n**2. Multi-Modal Asset Generation:**\n*   **Video:** Feeds detailed scene prompts to the **ByteDance Seedance** text-to-video model (via Wavespeed AI) to generate high-quality video clips.\n*   **Audio:** Simultaneously calls the **Fal AI** text-to-audio model to create custom, soothing ASMR sound effects that match the video's theme.\n*   **Assembly:** Automatically sequences the video clips and sound into a single, cohesive final video file using an FFMPEG API call.\n\n**3. Closed-Loop Publishing & Logging:**\n*   **Logging:** Initially logs the new idea to a Google Sheet with a status of \"In Progress\".\n*   **Publishing:** Automatically uploads the final, assembled video directly to your YouTube channel, setting the title and description from the AI's plan.\n*   **Updating:** Finds the original row in the Google Sheet and updates its status to \"Done\", adding a direct link to the newly published YouTube video.\n*   **Notifications:** Sends real-time alerts to Telegram and/or Gmail with the video title and link, confirming the successful publication.\n\n### Setup\n\n**Credentials:**\nYou will need to create credentials in your n8n instance for the following services:\n*   OpenAI API\n*   Wavespeed AI API (for Seedance)\n*   Fal AI API\n*   Google OAuth Credential (enable **YouTube Data API v3** and **Google Sheets API** in your Google Cloud Project)\n*   Telegram Bot Credential\n*   (Optional) Gmail OAuth Credential\n\n**Configuration:**\nThis is an advanced workflow. The initial setup should take approximately 15-20 minutes.\n*   **Google Sheet:** Create a Google Sheet with these columns: `idea`, `caption`, `production_status`, `youtube_url`. Add the **Sheet ID** to the Google Sheets nodes in the workflow.\n*   **Node Configuration:** In the `Telegram Notification` node, enter your own `Chat ID`. In the `Gmail Notification` node, update the recipient email address.\n*   **Activate:** Once configured, save and set the workflow to \"Active\" to let it run on its schedule.\n\n### How to customize\n\n*   **Creative Direction:** To change the style or theme of the videos (e.g., from kinetic sand to soap cutting), simply edit the `systemMessage` in the **\"2. Enrich Idea into Plan\"** and **\"Prompts AI Agent\"** nodes.\n\n*   **Initial Ideas:** To influence the AI's starting concepts, modify the prompt in the **\"1. Generate Trendy Idea\"** node.\n*   **Video & Sound:** To change the video duration or sound style, adjust the parameters in the **\"Create Clips\"** and **\"Create Sounds\"** nodes.\n*   **Notifications:** Add or remove notification channels (like Slack or Discord) after the **\"Upload to YouTube\"** node.\n",
+			"nodes": [
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"@n8n/n8n-nodes-langchain.toolThink",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.youTube",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleSheets"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:langchain"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 88.91,
+			"scoreBreakdown": {
+				"traction": 0.834,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.444
+			},
+			"source": "https://n8n.io/workflows/5110",
+			"author": "bilsimaging",
+			"success": true
+		},
+		{
+			"id": 5385,
+			"slug": "lead-generation-system-google-maps-to-email-scraper-with-goo-5385",
+			"name": "Lead Generation System: Google Maps to Email Scraper with Google Sheets Export",
+			"description": "# Google Maps Email Scraper System\n\n**Categories:** Lead Generation, Web Scraping, Business Automation\n\nThis workflow creates a completely free Google Maps email scraping system that extracts unlimited business emails without requiring expensive third-party APIs. Built entirely in N8N using simple HTTP requests and JavaScript, this system can generate thousands of targeted leads for any industry or location while operating at 99% free cost structure.\n\n## **Benefits**\n\n- **Zero API Costs** - Operates entirely through free Google Maps scraping without expensive third-party services\n- **Unlimited Lead Generation** - Extract emails from thousands of Google Maps listings across any industry\n- **Geographic Targeting** - Search by specific cities, regions, or business types for precise lead targeting\n- **Complete Automation** - From search query to organized email list with minimal manual intervention\n- **Built-in Data Cleaning** - Automatic duplicate removal, filtering, and data validation\n- **Scalable Processing** - Handle hundreds of businesses per search with intelligent rate limiting\n\n## **How It Works**\n\n**Google Maps Search Integration:**\n- Uses strategic HTTP requests to Google Maps search URLs\n- Processes search queries like \"Calgary + dentist\" to extract business listings\n- Bypasses API restrictions through direct HTML scraping techniques\n\n**Intelligent URL Extraction:**\n- Custom JavaScript regex patterns extract website URLs from Google Maps data\n- Filters out irrelevant domains (Google, schema, static files)\n- Returns clean list of actual business websites for processing\n\n**Smart Website Processing:**\n- Loop-based architecture prevents IP blocking through intelligent batching\n- Built-in delays and redirect handling for reliable scraping\n- Processes each website individually with error handling\n\n**Email Pattern Recognition:**\n- Advanced regex patterns identify email addresses within website HTML\n- Extracts contact emails, info emails, and administrative addresses\n- Handles multiple email formats and validation patterns\n\n**Data Aggregation & Cleaning:**\n- Automatically removes duplicate emails across all processed websites\n- Filters null entries and invalid email formats\n- Exports clean, organized email lists to Google Sheets\n\n## **Required Google Sheets Setup**\n\nCreate a Google Sheet with these exact column headers:\n\n**Search Tracking Sheet:**\n- `searches` - Contains your search queries (e.g., \"Calgary dentist\", \"Miami lawyers\")\n\n**Email Results Sheet:**\n- `emails` - Contains extracted email addresses from all processed websites\n\n**Setup Instructions:**\n1. Create Google Sheet with two tabs: \"searches\" and \"emails\"\n2. Add your target search queries to the searches tab (one per row)\n3. Connect Google Sheets OAuth credentials in n8n\n4. Update the Google Sheets document ID in all sheet nodes\n\nThe workflow reads search queries from the first sheet and exports results to the second sheet automatically.\n\n## **Business Use Cases**\n\n- **Local Service Providers** - Find competitors and potential partners in specific geographic areas\n- **B2B Sales Teams** - Generate targeted prospect lists for cold outreach campaigns  \n- **Marketing Agencies** - Build industry-specific lead databases for client campaigns\n- **Real Estate Professionals** - Identify businesses in target neighborhoods for commercial opportunities\n- **Franchise Development** - Research potential markets and existing competition\n- **Market Research** - Analyze business density and contact information across regions\n\n## **Revenue Potential**\n\nThis system transforms lead generation economics:\n- $0 per lead vs. $2-5 per lead from paid databases\n- Process 1,000+ leads daily without hitting API limits\n- Sell as a service for $500-2,000 per industry/location\n- Perfect for agencies offering lead generation to local businesses\n\n**Difficulty Level:** Intermediate  \n**Estimated Build Time:** 1-2 hours  \n**Monthly Operating Cost:** $0 (completely free)\n\n## **Watch My Complete Build Process**\n\nWant to watch me build this entire system live from scratch? I walk through every single step - including the JavaScript code, regex patterns, error handling, and all the debugging that goes into creating a bulletproof scraping system.\n\n🎥 **Watch My Live Build:** \"[Scrape Unlimited Leads WITHOUT Paying for APIs (99% FREE)](https://www.youtube.com/watch?v=OroDNJl-pyc)\"\n\nThis comprehensive tutorial shows the real development process - including writing custom JavaScript, handling rate limits, and building systems that actually work at scale without getting blocked.\n\n## **Set Up Steps**\n\n**Basic Workflow Architecture:**\n- Set up manual trigger for testing and Google Sheets integration\n- Configure initial HTTP request node for Google Maps searches  \n- Enable SSL ignore and response headers for reliable scraping\n\n**URL Extraction Code Setup:**\n- Configure JavaScript code node with custom regex patterns\n- Set up input data processing from Google Maps HTML responses\n- Implement URL filtering logic to remove irrelevant domains\n\n**Website Processing Pipeline:**\n- Add \"Split in Batches\" node for intelligent loop processing\n- Configure HTTP request nodes with proper delays and redirect handling\n- Set up error handling for websites that can't be scraped\n\n**Email Extraction System:**\n- Implement JavaScript code node with email-specific regex patterns\n- Configure email validation and format checking\n- Set up data aggregation for multiple emails per website\n\n**Data Cleaning & Export:**\n- Configure filtering nodes to remove null entries and duplicates\n- Set up \"Split Out\" node to aggregate emails into single list\n- Connect Google Sheets integration for organized data export\n\n**Testing & Optimization:**\n- Use limit nodes during testing to prevent IP blocking\n- Test with small batches before scaling to full searches\n- Implement proxy integration for high-volume usage\n\n## **Advanced Optimizations**\n\nScale the system with:\n- **Multi-Page Scraping:** Extract URLs from homepages, then scrape contact pages for more emails\n- **Proxy Integration:** Add residential proxies for unlimited scraping without rate limits\n- **Industry Templates:** Create pre-configured searches for different business types\n- **Contact Information Expansion:** Extract phone numbers, addresses, and social media profiles\n- **CRM Integration:** Automatically add leads to sales pipelines and marketing sequences\n\n## **Important Considerations**\n\n- **Rate Limiting:** Built-in delays prevent IP blocking during normal usage\n- **Scalability:** For high-volume usage, consider proxy services for unlimited requests\n- **Compliance:** Ensure proper usage rights for extracted contact information\n- **Data Quality:** System includes filtering but manual verification recommended for critical campaigns\n\n## **Check Out My Channel**\n\nFor more advanced automation systems and business-building strategies that generate real revenue, explore [my YouTube channel](https://www.youtube.com/@nicksaraev) where I share proven automation techniques used by successful agencies and entrepreneurs.",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.removeDuplicates",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.limit",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.googleSheets"
+			],
+			"tags": ["trigger:manual", "integration:removeDuplicates"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 88.89,
+			"scoreBreakdown": {
+				"traction": 0.778,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.667
+			},
+			"source": "https://n8n.io/workflows/5385",
+			"author": "nicksaraev",
+			"success": true
+		},
+		{
+			"id": 5678,
+			"slug": "automate-email-filtering-ai-summarization-100-free-effective-5678",
+			"name": "Automate Email Filtering & AI Summarization. 100% free & effective, works 7/24 ",
+			"description": "![dddss.png](fileId:1796)\n## Good to know:\nThis workflow automatically processes incoming emails (you can filter them base on your needs) and creates concise AI-powered summaries, then logs them to a Google Sheets spreadsheet for easy tracking and analysis.\n\n## Who is this for?\n\n➖Business professionals who receive many emails and need quick summaries\n➖Customer service teams tracking email communications\n➖Project managers monitoring email correspondence\n➖Anyone who wants to automatically organize and summarize their email communications\n\n## What problem is this workflow solving?\n\nThis workflow solves the problem of email overload by automatically reading incoming emails, generating concise summaries using AI, and organizing them in a structured format. It eliminates the need to manually read through every email to understand the key points and maintains a searchable record of communications.\n\n## What this workflow does:\n\n✅Monitors your Gmail inbox for new emails\n✅Filters emails based on specific criteria (sender validation)\n✅Extracts key information (sender, date, subject, content)\n✅Uses AI to generate concise summaries of email content\n✅Automatically logs all data including the AI summary to a Google Sheets spreadsheet\n\n## How it works:\n\n1️⃣Gmail trigger monitors for new emails at specified intervals\n2️⃣Email data is processed and formatted using JavaScript\n3️⃣A conditional check validates the sender\n4️⃣AI agent (powered by Groq's language model) reads the email content and generates a summary\n5️⃣All information is automatically appended to a Google Sheets document\n\n## How to use:\n\nSet up Gmail OAuth2 credentials in n8n\nConfigure Google Sheets OAuth2 credentials\nSet up Groq API credentials for AI processing\nCreate a Google Sheets document and update the document ID\nCustomize the sender validation criteria as needed\nActivate the workflow\n\n## Requirements:\n\n✅n8n instance (cloud or self-hosted)\n✅Gmail account with OAuth2 access\n✅Google Sheets account\n✅AI API\n✅Basic understanding of n8n workflow\n\n## Customizing this workflow:\n\n🟢Modify the Gmail trigger filters to target specific labels or criteria\n🟢Adjust the sender validation logic in the conditional node\n🟢Customize the AI prompt to change summary style or focus\n🟢Add additional data fields to the Google Sheets output\n🟢Change the polling frequency for checking new emails\n🟢Switch to different AI models by replacing the Groq node\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.gmailTrigger",
+				"n8n-nodes-base.if",
+				"@n8n/n8n-nodes-langchain.lmChatGroq",
+				"n8n-nodes-base.code"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:langchain"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 88.39,
+			"scoreBreakdown": {
+				"traction": 0.67,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5678",
+			"author": "arre",
+			"success": true
+		},
+		{
+			"id": 2860,
+			"slug": "ai-automated-hr-workflow-for-cv-analysis-and-candidate-evalu-2860",
+			"name": "AI Automated HR Workflow for CV Analysis and Candidate Evaluation",
+			"description": "### How it Works\n\nThis workflow automates the process of handling job applications by extracting relevant information from submitted CVs, analyzing the candidate's qualifications against a predefined profile, and storing the results in a Google Sheet. Here’s how it operates:\n\n1. **Data Collection and Extraction**: \n   - The workflow begins with a form submission (`On form submission` node), which triggers the extraction of data from the uploaded CV file using the `Extract from File` node.\n   - Two `informationExtractor` nodes (`Qualifications` and `Personal Data`) are used to parse specific details such as educational background, work history, skills, city, birthdate, and telephone number from the text content of the CV.\n\n2. **Processing and Evaluation**:\n   - A `Merge` node combines the extracted personal and qualification data into a single output.\n   - This merged data is then passed through a `Summarization Chain` that generates a concise summary of the candidate’s profile.\n   - An `HR Expert` chain evaluates the candidate against a desired profile (`Profile Wanted`), assigning a score and providing considerations for hiring.\n   - Finally, all collected and processed data including the evaluation results are appended to a Google Sheets document via the `Google Sheets` node for further review or reporting purposes [[9]].\n\n### Set Up Steps\n\nTo replicate this workflow within your own n8n environment, follow these steps:\n\n1. **Configuration**:\n   - Begin by setting up an n8n instance if you haven't already; you can sign up directly on their website or self-host the application.\n   - Import the provided JSON configuration into your n8n workspace. Ensure that all necessary credentials (e.g., Google Drive, Google Sheets, OpenAI API keys) are correctly configured under the Credentials section since some nodes require external service integrations like Google APIs and OpenAI for language processing tasks.\n\n2. **Customization**:\n   - Adjust the parameters of each node according to your specific requirements. For example, modify the fields in the `formTrigger` node to match what kind of information you wish to collect from applicants.\n   - Customize the prompts given to AI models in nodes like `Qualifications`, `Summarization Chain`, and `HR Expert` so they align with the type of analyses you want performed on the candidates' profiles.\n   - Update the destination settings in the `Google Sheets` node to point towards your own spreadsheet where you would like the final outputs recorded.\n\n---\n\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.extractFromFile",
+				"@n8n/n8n-nodes-langchain.informationExtractor",
+				"@n8n/n8n-nodes-langchain.chainSummarization",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:langchain"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 88.38,
+			"scoreBreakdown": {
+				"traction": 0.69,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.917
+			},
+			"source": "https://n8n.io/workflows/2860",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 5962,
+			"slug": "track-seo-keyword-rankings-with-bright-data-mcp-and-gpt-4o-a-5962",
+			"name": "Track SEO Keyword Rankings with Bright Data MCP and GPT-4o AI Analysis",
+			"description": "*This workflow contains community nodes that are only compatible with the self-hosted version of n8n.*\n\nThis workflow automatically monitors keyword rankings across search engines to track SEO performance and identify optimization opportunities. It saves you time by eliminating the need to manually check keyword positions and provides comprehensive ranking data for strategic SEO decision making.\n\n## Overview\n\nThis workflow automatically scrapes search engine results pages (SERPs) to track keyword rankings, competitor positions, and search features. It uses Bright Data to access search results without restrictions and AI to intelligently parse ranking data, track changes, and identify SEO opportunities.\n\n## Tools Used\n\n- **n8n**: The automation platform that orchestrates the workflow\n- **Bright Data**: For scraping search engine results without being blocked\n- **OpenAI**: AI agent for intelligent ranking analysis and SEO insights\n- **Google Sheets**: For storing keyword ranking data and tracking changes\n\n## How to Install\n\n1. **Import the Workflow**: Download the .json file and import it into your n8n instance\n2. **Configure Bright Data**: Add your Bright Data credentials to the MCP Client node\n3. **Set Up OpenAI**: Configure your OpenAI API credentials\n4. **Configure Google Sheets**: Connect your Google Sheets account and set up your ranking tracking spreadsheet\n5. **Customize**: Define target keywords and ranking monitoring parameters\n\n## Use Cases\n\n- **SEO Teams**: Track keyword performance and identify ranking improvements\n- **Content Marketing**: Monitor content ranking success and optimization needs\n- **Competitive Analysis**: Track competitor keyword rankings and strategies\n- **Digital Marketing**: Measure organic search performance and ROI\n\n## Connect with Me\n\n- **Website**: https://www.nofluff.online\n- **YouTube**: https://www.youtube.com/@YaronBeen/videos\n- **LinkedIn**: https://www.linkedin.com/in/yaronbeen/\n- **Get Bright Data**: https://get.brightdata.com/1tndi4600b25 (Using this link supports my free workflows with a small commission)\n\n#n8n #automation #keywordrankings #seo #searchrankings #brightdata #webscraping #seotools #n8nworkflow #workflow #nocode #ranktracking #keywordmonitoring #seoautomation #searchmarketing #organicseo #seoresearch #rankinganalysis #keywordanalysis #searchengines #seomonitoring #digitalmarketing #serp #keywordtracking #seoanalytics #searchoptimization #rankingreports #keywordresearch #seoinsights #searchperformance",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-mcp.mcpClientTool",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.outputParserAutofixing",
+				"@n8n/n8n-nodes-langchain.outputParserStructured"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:langchain"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 88.29,
+			"scoreBreakdown": {
+				"traction": 0.689,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.9
+			},
+			"source": "https://n8n.io/workflows/5962",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 10000,
+			"slug": "auto-create-tiktok-videos-with-veed-io-ai-avatars-elevenlabs-10000",
+			"name": "Auto-Create TikTok Videos with VEED.io AI Avatars, ElevenLabs & GPT-4",
+			"description": "# 💥 Viral TikTok Video Machine: Auto-Create Videos with Your AI Avatar\n\n![Workflow Overview](https://www.dr-firas.com/workflow-veed.png)\n\n---\n\n### 🎯 Who is this for?\nThis workflow is for **content creators, marketers, and agencies** who want to use **Veed.io’s AI avatar technology** to produce short, engaging TikTok videos automatically.  \nIt’s ideal for creators who want to appear on camera without recording themselves, and for teams managing multiple brands who need to generate videos at scale.\n\n---\n\n### ⚙️ What problem this workflow solves\nManually creating videos for TikTok can take hours — finding trends, writing scripts, recording, and editing.  \nBy combining **Veed.io**, **ElevenLabs**, and **GPT-4**, this workflow transforms a simple Telegram input into a **ready-to-post TikTok video** featuring your **AI avatar powered by Veed.io** — speaking naturally with your cloned voice.\n\n---\n\n### 🚀 What this workflow does\nThis automation links Veed.io’s video-generation API with multiple AI tools:\n- Analyzes TikTok trends via **Perplexity AI**  \n- Writes a 10-second **viral script** using **GPT-4**  \n- Generates your **voiceover** via **ElevenLabs**  \n- Uses **Veed.io (Fabric 1.0 via FAL.ai)** to animate your avatar and sync the lips to the voice  \n- Creates an engaging **caption + hashtags** for TikTok virality  \n- Publishes the video automatically via **Blotato TikTok API**  \n- Logs all results to **Google Sheets** for tracking\n\n---\n\n### 🧩 Setup\n1. **Telegram Bot**\n   - Create your bot via [@BotFather](https://t.me/BotFather)\n   - Configure it as the trigger for sending your **photo** and **theme**\n\n2. **Connect Veed.io**\n   - Create an account on [Veed.io](https://www.veed.io)  \n   - Get your **FAL.ai API key** (Veed Fabric 1.0 model)  \n   - Use HTTPS image/audio URLs compatible with Veed Fabric  \n\n3. **Other APIs**\n   - Add **Perplexity**, **ElevenLabs**, and **Blotato TikTok** keys  \n   - Connect your Google Sheet for logging results  \n\n---\n\n### 🛠️ How to customize this workflow\n- **Change your Avatar:** Upload a new image through Telegram, and **Veed.io** will generate a new talking version automatically.  \n- **Modify the Script Style:** Adjust the GPT prompt for tone (educational, funny, storytelling).  \n- **Adjust Voice Tone:** Tweak **ElevenLabs** stability and similarity settings.  \n- **Expand Platforms:** Add Instagram, YouTube Shorts, or X (Twitter) posting nodes.  \n- **Track Performance:** Customize your Google Sheet to measure your most successful Veed.io-based videos.\n\n---\n\n### 🧠 Expected Outcome\nIn just a few seconds after sending your photo and theme, this workflow — powered by **Veed.io** — creates a **fully automated TikTok video** featuring your AI avatar with natural lip-sync and voice.  \nThe result is a continuous stream of **viral short videos**, made without cameras, editing, or effort.\n\n---\n\n✅ **Import the JSON file in n8n**, add your API keys (including Veed.io via FAL.ai), and start generating viral TikTok videos starring your AI avatar today!\n\n### 🎥 [Watch This Tutorial](https://youtu.be/EOe7h1resHk)\n\n![VEED logo](https://www.dr-firas.com/VEED.png)\n\n---\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/Viral-TikTok-Video-Machine-Auto-Create-Videos-with-Your-AI-Avatar-2943d6550fd9804a947ae762d60d76f5?source=copy_link)\n\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https://www.youtube.com/channel/UCriIQI8uaoEro5FEnOpeidQ)",
+			"nodes": [
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.perplexity",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.wait",
+				"@blotato/n8n-nodes-blotato.blotato",
+				"n8n-nodes-base.merge"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:blotato"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 87.92,
+			"scoreBreakdown": {
+				"traction": 0.798,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.393
+			},
+			"source": "https://n8n.io/workflows/10000",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 3586,
+			"slug": "ai-powered-whatsapp-chatbot-for-text-voice-images-pdfs-with--3586",
+			"name": "AI-Powered WhatsApp Chatbot 🤖📲 for Text, Voice, Images & PDFs with memory 🧠",
+			"description": "This workflow is a highly advanced **multimodal AI assistant** designed to operate through **WhatsApp**. It can **understand and respond** to text, images, voice messages, and PDF documents by combining **OpenAI models** with smart logic to adapt to the content received.\n\n---\n\n### 🎯 **Core Features**\n\n#### 📥 1. **Automatic Message Type Detection**\nUsing the `Input type` node, the bot detects whether the user has sent:\n- Text\n- Voice messages\n- Images\n- Files (PDF)\n- Other unsupported content\n\n#### 💬 2. **Smart Text Message Handling**\n- Text messages are processed by an **OpenAI GPT-4o-mini agent** with a customized system prompt.\n- Replies are concise, accurate, and formatted for mobile readability.\n\n#### 🖼️ 3. **Image Analysis & Description**\n- Images are downloaded, converted to base64, and analyzed by an **image-aware AI model**.\n- The output is a rich, structured description, designed for visually impaired users or visual content interpretation.\n\n#### 🎙️ 4. **Voice Message Transcription & Reply**\n- Audio messages are downloaded and transcribed using OpenAI Whisper.\n- The transcribed text is analyzed and answered by the AI.\n- Optionally, the AI reply can be **converted back to voice** using **OpenAI's text-to-speech**, and sent as an audio message.\n\n#### 📄 5. **PDF Document Extraction & Summary**\n- Only PDFs are allowed (filtered via MIME type).\n- The document’s content is extracted and combined with the user's message.\n- The AI then provides a relevant summary or answer.\n\n#### 🧠 6. **Contextual Memory**\n- Each user has a personalized session ID with a memory window of 10 interactions.\n- This ensures a more natural and contextual conversation flow.\n\n\n---\n\n### **How It Works**  \n\nThisworkflow is designed to handle incoming WhatsApp messages and process different types of inputs (**text, audio, images, and PDF documents**) using **AI-powered analysis**. Here’s how it functions:  \n\n- **Trigger**: The workflow starts with the **WhatsApp Trigger** node, which listens for incoming messages (text, audio, images, or documents).  \n- **Input Routing**: The **Input type** (Switch node) checks the message type and routes it to the appropriate processing branch:  \n  - **Text**: Directly forwards the message to the AI agent for response generation.  \n  - **Audio**: Downloads the audio file, transcribes it using OpenAI, and sends the transcription to the AI agent.  \n  - **Image**: Downloads the image, analyzes it with OpenAI’s GPT-4 model, and generates a detailed description.  \n  - **PDF Document**: Downloads the file, extracts text, and processes it with the AI agent.  \n  - **Unsupported Formats**: Sends an error message if the input is not supported.  \n- **AI Processing**: The **AI Agent1** node, powered by OpenAI, processes the input (text, transcribed audio, image description, or PDF content) and generates a response.  \n- **Response Handling**:  \n  - For **audio inputs**, the AI’s response is converted back into speech (using OpenAI’s TTS) and sent as a voice message.  \n  - For **other inputs**, the response is sent as a text message via WhatsApp.  \n- **Memory**: The **Simple Memory** node maintains conversation context for follow-up interactions.  \n\n###  **Setup Steps**  \nTo deploy this workflow in n8n, follow these steps:  \n\n1. **Configure WhatsApp API Credentials**:  \n   - Set up **WhatsApp Business API** credentials (Meta Developer Account).  \n   - Add the credentials in the **WhatsApp Trigger**, **Get Image/Audio/File URL**, and **Send Message** nodes.  \n\n**Set Up OpenAI Integration**:  \n   - Provide an **OpenAI API key** in the **Analyze Image**, **Transcribe Audio**, **Generate Audio Response**, and **AI Agent1** nodes.  \n\n **Adjust Input Handling (Optional)**:  \n   - Modify the **Switch node (\"Input type\")** to handle additional message types if needed.  \n   - Update the **\"Only PDF File\" IF node** to support other document formats.  \n\n**Test & Deploy**:  \n   - Activate the workflow and test with different message types (text, audio, image, PDF).  \n   - Ensure responses are correctly generated and sent back via WhatsApp.  \n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.whatsAppTrigger",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.extractFromFile",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.whatsApp",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.switch"
+			],
+			"tags": ["trigger:other", "ai", "integration:whatsApp"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 87.87,
+			"scoreBreakdown": {
+				"traction": 0.778,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.462
+			},
+			"source": "https://n8n.io/workflows/3586",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 13270,
+			"slug": "use-skills-in-n8n-agent-node-13270",
+			"name": "Use skills In n8n agent node",
+			"description": "This template gives you a framework to use skills in any n8n agent. You can use this as a starting point and add any other tools or patterns needed for your use case.\n\n### What are “skills”?\n\nSkills are a context management standard created by Anthropic for use in Claude code. Basically, instead of having a HUGE system prompt, skills split that into lots of small, structured instruction files that tell an agent *how* to do a specific kind of task. Instead of stuffing a massive prompt full of rules, the agent:\n\n* finds the relevant skill file\n* reads it\n* and follows the steps inside\n\nIt’s a simple pattern that makes managing system prompts for general purpose agents much more straightforward.\n\nSee an example of a skills repo [here](https://github.com/anthropics/knowledge-work-plugins).\n\n### What this workflow does\n\n* Responds to messages in n8n Chat (or Chat Hub)\n* Builds an “available skills” index from one or more GitHub repos\n* Lets the agent browse folders + fetch skill files (Markdown) as needed\n* Uses the skill content to guide how it completes tasks\n\n### How it (roughly) works\n\n1. A chat message comes in.\n2. The workflow lists directories in the configured skills repos (root + `/skills` if present), filters out noise, and merges everything into one directory map.\n3. That directory map gets injected into the agent’s system prompt so it knows what skill files exist.\n4. When it needs instructions, it uses tools:\n\n   * **List Files by Path Name** to explore folders\n   * **Get a File From GitHub** to pull the skill file as raw text (no base64)\n\n### Same “skills” pattern as the CLI tools\n\nThe flow is: find a skill → open it → follow the steps, the same way it works in the CLI tools, but running inside n8n, so you **don’t need to download or install anything locally**.\n\n### How to set it up\n1. (Required) Add your GitHub credentials to each node that needs it\n2. (Required) Add your OpenRouter credentials to the chat node or replace with the provider of your choosing\n3. (Optional) Add more repos to `SKILLS_REPOS` (any skills GitHub repo works as long as your credentials have access to it, such as any public repo)\n4. (Optional) Add more tools and turn it into whatever agent you actually need",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.github",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.githubTool",
+				"n8n-nodes-base.httpRequestTool",
+				"n8n-nodes-base.merge"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:langchain"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 87.62,
+			"scoreBreakdown": {
+				"traction": 0.669,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.846
+			},
+			"source": "https://n8n.io/workflows/13270",
+			"author": "liammcgarrigle",
+			"success": true
+		},
+		{
+			"id": 4484,
+			"slug": "build-a-voice-ai-chatbot-with-elevenlabs-and-infranodus-know-4484",
+			"name": "Build a Voice AI Chatbot with ElevenLabs and InfraNodus Knowledge Experts",
+			"description": "## Set Up ElevenLabs Voice Chat Agent using Graph RAG Knowledge Graphs as Experts\n\nThis workflow creates an AI voice chatbot agent that has access to several knowledge bases at the same time (used as \"experts\"). \n\nThese knowledge bases are provided using the [InfraNodus GraphRAG](https://infranodus.com/use-case/ai-knowledge-graphs) using the knowledge graphs and providing high-quality responses without the need to set up complex RAG vector store workflows.\n\nWe use [ElevenLabs](https://elevenlabs.io) to set up a voice agent that can be embedded to any website or used via their API.\n\nThe advantages of using GraphRAG instead of the standard vector stores for knowledge are:\n\n- Easy and quick to set up (no complex data import workflows needed) and to update with new knowledge\n- A knowledge graph has a holistic overview of your knowledge base\n- Better retrieval of relations between the document chunks = higher quality responses\n- Ability to reuse in other n8n workflows\n\n![InfraNodus knowledge graph](https://support.noduslabs.com/hc/article_attachments/20319018287260)\n\n\n## How it works\nThis template uses the n8n AI agent node as an orchestrating agent that decides which tool (knowledge graph) to use based on the user's prompt. \n\nThe user's prompt is received from the ElevenLabs Conversational AI agent via an n8n Webhook, which also takes care of the voice interaction. \n\nThe response from n8n is then sent to the Webhook, which is polled by the ElevenLabs voice agent. This agent processes the response and provides the final answer.\n\nHere's a description step by step:\n\n- The user submits a question using ElevenLabs voice interface\n- The question is sent via the `knowledge_base` tool in ElevenLabs to the n8n Webhook with the POST request containing the user's `prompt` and `sessionID` for Chat Memory node in n8n.\n- The n8n AI agent node checks a list of tools it has access to. Each tool has a description of the knowledge auto-generated by InfraNodus (we call each tool an \"expert\"). \n- The n8n AI agent decides which tool should be used to generate a response. It may reformulate user's query to be more suitable for the expert. \n- The query is then sent to the InfraNodus HTTP node endpoint, which will query the graph that corresponds to that expert. \n- Each InfraNodus GraphRAG expert provides a rich response that takes the whole context into account and provides a response from each expert (graph) along with a list of relevant statements retrieved using a combination or RAG and GraphRAG. \n- The n8n AI Agent node integrates the responses received from the experts to produce the final answer.\n- The final answer is sent back to the Webhook endpoint\n- ElevenLabs conversational AI agent picks up the response arriving from the `knowledge_base` tool via the webhook and then condenses it for conversational format and transforms text into voice.\n\n## How to use\n\nYou need an [InfraNodus GraphRAG API account and key](https://infranodus.com/use-case/ai-knowledge-graphs) to use this workflow. \n\n- Create an InfraNodus account\n- Get the API key at [https://infranodus.com/api-access](https://infranodus.com/api-access) and create a Bearer authorization key for the InfraNodus HTTP nodes.\n- Create a separate knowledge graph for each expert (using PDF / content import options) in InfraNodus\n- For each graph, go to the workflow, paste the name of the graph into the `body` `name` field.\n- Keep other settings intact or learn more about them at the [InfraNodus access points](https://support.noduslabs.com/hc/en-us/articles/13605983537692-InfraNodus-API-Access-Points) page. \n- Once you add one or more graphs as experts to your flow, add the LLM key to the OpenAI node and launch the workflow\n- You will also need to set up an ElevenLabs account and to set up a conversational AI agent there. See the Post note in the n8n workflow for a complete step-by-step description or our [support article on setting up ElevenLabs AI voice agent](https://support.noduslabs.com/hc/en-us/articles/20318967066396-How-to-Build-a-Text-Voice-AI-Agent-Chatbot-with-n8n-Elevenlabs-and-InfraNodus)\n- Once the voice AI agent is ready, you might want to combine it with a [text AI chatbot workflow](https://n8n.io/workflows/4402-ai-chatbot-agent-with-a-panel-of-experts-using-infranodus-graphrag-knowledge/) so your users have a choice between the text and voice interaction. In that case, you may be interested to use our free open-source [website popup chat widget popupchat.dev](https://popupchat.dev) where you can create an embed code to add to your blog or website and allow the user to choose between the text and voice interaction.\n\n## Requirements\n\n- An [InfraNodus](https://infranodus.com/use-case/ai-knowledge-graphs) account and API key\n- An OpenAI (or any other LLM) API key\n- An ElevenLabs account\n\n## FAQ\n\n**1. How many \"experts\" should I aim for?**\n\nWe recommend to aim for the number of experts as the optimal number of people in a team, which is usually 2-7. If you add more experts, your AI orchestrating agent will have troubles choosing the most suitable \"expert\" tool for the user's query. You can mitigate this by specifying in the AI agent description that it can choose maximum 3-7 experts to provide a response.\n\n**2. Why use InfraNodus GraphRAG and not standard vector store for knowledge?**\n\nFirst, vector stores are complex to set up and to update. You'd need a separate workflow for that, decide on the vector dimensions, add metadata to your knowledge, etc.\nWith InfraNodus, you have a complete RAG / GraphRAG solution under the hood that is easy to set up and provides high-quality responses that takes the overall structure and the relations between your ideas into account. \n\n**3 Why not use ElevenLabs' own knowledge?**\n\nOne of the reasons is that you want your knowledge base to be in one place so you can reuse it in other n8n workflows. Another reason is that you will not have such a good separation between the \"experts\" when you converse with the agent. So the answers you get will be based on top matches from all the books / articles you upload, while with the InfraNodus GraphRAG setup you can better control which graphs are consulted as experts and have an explicit way to display this data.\n\n\n\n## Customizing this workflow\n\nYou can use this same workflow with a Telegram bot, so you can interact with it using Telegram. There are many more customizations available on our [GitHub repo for n8n workflows](https://github.com/infranodus/n8n-infranodus-workflow-templates).\n\nCheck out the **complete setup guide** for this workflow at [https://support.noduslabs.com/hc/en-us/articles/20318967066396-How-to-Build-a-Text-Voice-AI-Agent-Chatbot-with-n8n-Elevenlabs-and-InfraNodus](https://support.noduslabs.com/hc/en-us/articles/20318967066396-How-to-Build-a-Text-Voice-AI-Agent-Chatbot-with-n8n-Elevenlabs-and-InfraNodus)\n\nAlso check out the **video tutorial** with a demo:\n\n[![Video tutorial](https://img.youtube.com/vi/07-HZZQs5h0/sddefault.jpg)](https://www.youtube.com/watch?v=07-HZZQs5h0)\n\n\n\n\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.httpRequestTool",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.respondToWebhook",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:langchain"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 87.53,
+			"scoreBreakdown": {
+				"traction": 0.701,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.7
+			},
+			"source": "https://n8n.io/workflows/4484",
+			"author": "infranodus",
+			"success": true
+		},
+		{
+			"id": 2846,
+			"slug": "ai-voice-chatbot-with-elevenlabs-openai-for-customer-service-2846",
+			"name": "AI Voice Chatbot with ElevenLabs & OpenAI for Customer Service and Restaurants",
+			"description": "The \"Voice RAG Chatbot with ElevenLabs and OpenAI\" workflow in n8n is designed to create an interactive voice-based chatbot system that leverages both text and voice inputs for providing information. Ideal for shops, commercial activities and restaurants\n\n### How it works:\n\nHere's how it operates:\n\n1. **Webhook Activation**: The process begins when a user interacts with the voice agent set up on [ElevenLabs](https://try.elevenlabs.io/ahkbf00hocnu), triggering a webhook in n8n. This webhook sends a question from the user to the AI Agent node.\n2. **AI Agent Processing**: Upon receiving the query, the AI Agent node processes the input using predefined prompts and tools. It extracts relevant information from the knowledge base stored within the Qdrant vector database.\n3. **Knowledge Base Retrieval**: The Vector Store Tool node interfaces with the Qdrant Vector Store to retrieve pertinent documents or data segments matching the user’s query.\n4. **Text Generation**: Using the retrieved information, the OpenAI Chat Model generates a coherent response tailored to the user’s question.\n5. **Response Delivery**: The generated response is sent back through another webhook to ElevenLabs, where it is converted into speech and delivered audibly to the user.\n6. **Continuous Interaction**: For ongoing conversations, the Window Buffer Memory ensures context retention by maintaining a history of interactions, enhancing the conversational flow.\n\n### Set up steps:\n\nTo configure this workflow effectively, follow these detailed setup instructions:\n\n1. **ElevenLabs Agent Creation**:\n\t- Create a FREE account on [ElevenLabs](https://try.elevenlabs.io/ahkbf00hocnu)\n   - Begin by creating an agent on ElevenLabs (e.g., named 'test_n8n').\n   - Customize the first message and define the system prompt specific to your use case, such as portraying a character like a waiter at \"Pizzeria da Michele\".\n   - Add a Webhook tool labeled 'test_chatbot_elevenlabs' configured to receive questions via POST requests.\n\n2. **Qdrant Collection Initialization**:\n   - Utilize the HTTP Request nodes ('Create collection' and 'Refresh collection') to initialize and clear existing collections in Qdrant. Ensure you update placeholders `QDRANTURL` and `COLLECTION` accordingly.\n\n3. **Document Vectorization**:\n   - Use Google Drive integration to fetch documents from a designated folder. These documents are then downloaded and processed for embedding.\n   - Employ the Embeddings OpenAI node to generate embeddings for the downloaded files before storing them into Qdrant via the Qdrant Vector Store node.\n\n4. **AI Agent Configuration**:\n   - Define the system prompt for the AI Agent node which guides its behavior and responses based on the nature of queries expected (e.g., product details, troubleshooting tips).\n   - Link necessary models and tools including OpenAI language models and memory buffers to enhance interaction quality.\n\n5. **Testing Workflow**:\n   - Execute test runs of the entire workflow by clicking 'Test workflow' in n8n alongside initiating tests on the ElevenLabs side to confirm all components interact seamlessly.\n   - Monitor logs and outputs closely during testing phases to ensure accurate data flow between systems.\n\n6. **Integration with Website**:\n   - Finally, integrate the chatbot widget onto your business website replacing placeholder AGENT_ID with the actual identifier created earlier on ElevenLabs.\n\nBy adhering to these comprehensive guidelines, users can successfully deploy a sophisticated voice-driven chatbot capable of delivering precise answers utilizing advanced retrieval-augmented generation techniques powered by OpenAI and ElevenLabs technologies.\n\n----\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.toolVectorStore",
+				"@n8n/n8n-nodes-langchain.vectorStoreQdrant",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterTokenSplitter",
+				"n8n-nodes-base.respondToWebhook",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.webhook",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow"
+			],
+			"tags": ["trigger:manual", "ai", "integration:langchain"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 87.44,
+			"scoreBreakdown": {
+				"traction": 0.691,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.722
+			},
+			"source": "https://n8n.io/workflows/2846",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 10212,
+			"slug": "generate-funny-ai-videos-with-sora-2-and-auto-publish-to-tik-10212",
+			"name": "Generate Funny AI Videos with Sora 2 and Auto-Publish to TikTok",
+			"description": "This automation creates a fully integrated pipeline to **generate AI-powered videos**, **store them**, and **publish them on TikTok** — all automatically.\nIt connects **OpenAI Sora 2**, and **Postiz (for TikTok publishing)** to streamline content creation.\n\n---\n\n### **Key Benefits**\n\n✅ **Full Automation** – From text prompt to TikTok upload, everything happens automatically with no manual intervention once set up.\n✅ **Centralized Control** – Google Sheets acts as a simple dashboard to manage prompts, durations, and generated results.\n✅ **AI-Powered Creativity** – Uses **OpenAI Sora 2** for realistic video generation and **GPT-5** for optimized titles.\n✅ **Social Media Integration** – Seamlessly posts videos to **TikTok** via **Postiz**, ready for your audience.\n✅ **Scalable & Customizable** – Can easily be extended to other platforms like YouTube, Instagram, or LinkedIn.\n✅ **Time-Saving** – Eliminates repetitive steps like manual video uploads or caption writing.\n\n---\n\n### How it works\n\nThis workflow automates the end-to-end process of generating AI videos and publishing them to TikTok. It is triggered either manually or on a recurring schedule.\n\n1.  **Trigger & Data Fetch:** The workflow starts by checking a specified Form for new entries. It looks for rows where a video has been requested (a \"PROMPT\" is filled) but not yet generated (the \"VIDEO\" column is empty).\n\n2.  **AI Video Generation:** For each new prompt found, the workflow sends a request to the **Fal.ai Sora 2** model to generate a video. It then enters a polling loop, repeatedly checking the status of the generation request every 60 seconds until the video is \"COMPLETED\".\n\n3.  **Post-Processing & Upload:** Once the video is ready, the workflow performs several actions in parallel:\n    *   **Fetch Video & Store:** It retrieves the final video URL, downloads the video file\n    *   **Generate Title:** It uses the **OpenAI GPT-4o-mini** model to analyze the original prompt and generate an optimized, engaging title for the video.\n    *   **Publish to TikTok:** The video file is uploaded to **Postiz**, a social media scheduling tool, which then automatically publishes it to a connected TikTok channel, using the AI-generated title as the post's caption.\n\n---\n### Set up steps\n\nTo make this workflow functional, you need to complete the following configuration steps:\n\n1.  **Prepare the Google Sheet:**\n    *   Create a Form with at least \"PROMPT\", \"DURATION\", and \"VIDEO\" fields.\n\n2.  **Configure Fal.ai for Video Generation:**\n    *   Create an account at [Fal.ai](https://fal.ai/) and obtain your API key.\n    *   In both the **\"Create Video\"** and **\"Get status\"** HTTP Request nodes, set up the \"Header Auth\" credential.\n    *   Set the `Name` to `Authorization` and the `Value` to `Key YOUR_API_KEY`.\n\n3.  **Set up TikTok Publishing via Postiz:**\n    *   Create an account on [Postiz](https://postiz.com/) and connect your TikTok account to get a **Channel ID**.\n    *   Obtain your Postiz API key.\n    *   In the **\"Upload Video to Postiz\"** and **\"TikTok\" (Postiz)** nodes, configure the API credentials.\n    *   In the **\"TikTok\"** node, replace the placeholder `\"XXX\"` in the `integrationId` field with your actual TikTok Channel ID from Postiz.\n\n4.  **(Optional) Configure AI Title Generation:**\n    *   The **\"Generate title\"** node uses OpenAI. Ensure you have valid OpenAI API credentials configured in n8n for this node to work.\n\n---\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). \n## Header 2",
+			"nodes": [
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.if",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-postiz.postiz",
+				"n8n-nodes-base.formTrigger"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:httpRequest"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 87.4,
+			"scoreBreakdown": {
+				"traction": 0.72,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.6
+			},
+			"source": "https://n8n.io/workflows/10212",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4295,
+			"slug": "automate-business-lead-scraping-from-apify-to-google-sheets--4295",
+			"name": "Automate Business Lead Scraping from Apify to Google Sheets with Data Cleaning",
+			"description": "\n## 🚀 Automated Lead Scraper Workflow (Apify + n8n + Google Sheets)\n\n### 🧠 What It Does\n\nThis n8n workflow automates the process of scraping leads using **Apify**, cleaning the extracted data, and exporting it to **Google Sheets**—ready for use in outreach, prospecting, or CRM pipelines.\n\n---\n\n### 🔄 Workflow Steps\n\n1. ✅ **Start** – Manually triggers the workflow.\n2. 🧩 **Set Variables** – Stores required Apify credentials:\n\n   * `APIFY_TOKEN`: Your Apify token.\n   * `APIFY_TASK_ID`: The Apify task to run.\n3. 🕸️ **Run Apify Scraper** – Launches the scraper and fetches the dataset.\n4. 🧹 **Clean Data** – Processes scraped results to:\n\n   * ✂️ Strip non-numeric characters from phone numbers.\n   * ✉️ Format emails (lowercase + trimmed).\n5. 📊 **Export to Google Sheets** – Appends clean data to your spreadsheet:\n\n   * 🏢 `company name` → from `title`\n   * 📞 `phone` → cleaned number\n   * 📍 `address` → from scraped info\n\n---\n\n### 🛠️ Requirements\n\n* 🕷️ **Apify Account**\n\n  * A valid `APIFY_TOKEN`\n  * An existing Apify task (`APIFY_TASK_ID`)\n\n* 📗 **Google Sheets Access**\n\n  * OAuth2 credentials set up in n8n (e.g., `\"Google Sheets account 2\"`)\n\n---\n\n### 🚦 How to Use\n\n1. ⚙️ Open the **Variables** node and plug in your Apify credentials.\n2. 📄 Confirm the **Google Sheets** node points to your desired spreadsheet.\n3. ▶️ Run the workflow manually from the **Start** node.\n\n---\n\n### 📥 Output\n\nA ready-to-use sheet of **cleaned lead data** containing:\n\n* Company names\n* Phone numbers\n* Addresses\n\n---\n\n### 💼 Perfect For:\n\n* Sales teams doing outbound prospecting\n* Marketers building lead lists\n* Agencies running data aggregation tasks\n\n---\n\n",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:manual", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 87.22,
+			"scoreBreakdown": {
+				"traction": 0.611,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4295",
+			"author": "dae221",
+			"success": true
+		},
+		{
+			"id": 4005,
+			"slug": "ai-generated-linkedin-posts-with-openai-google-sheets-email--4005",
+			"name": "AI-Generated LinkedIn Posts with OpenAI, Google Sheets & Email Approval Workflow",
+			"description": "### How it works\nThis workflow automates the process of creating, approving, and optionally posting LinkedIn content from a Google Sheet. Here's a high-level overview:\n1. **Scheduled Trigger**: Runs automatically based on your defined time interval (daily, weekly, etc.).\n2. **Fetch Data from Google Sheets**: Pulls the first row from your sheet where Status is marked as Pending.\n3. **Generate LinkedIn Post Content**: Uses OpenAI to create a professional LinkedIn post using the Post Description and Instructions from the sheet.\n4. **Format & Prepare Data**: Formats the generated content along with the original instruction and post description for email.\n5. **Send for Approval**: Sends an email to a predefined user (e.g., marketing team) with a custom form for approval, including a dropdown to accept/reject and an optional field for edits.\n6. **(Optional) Image Fetch**: Downloads an image from a URL (if provided in the sheet) for future use in post visuals.\n\n\n### Set up steps\nYou’ll need the following before you start:\n\n- A Google Sheet with the following columns: Post Description, Instructions, Image (URL), Status\n- Access to an OpenAI API key\n- A connected Gmail account for sending approval emails\n- Your own Google Sheets and Gmail credentials added in n8n\n\n### Steps:\n1. Google Sheet Preparation:\nCreate a new Google Sheet with the mentioned columns (Post Description, Instructions, Image, Status, Output, Post Link).\nAdd a row with test data and set Status to Pending.\n\n2. Credentials:\nIn n8n, create OAuth2 credentials for:\na. Google Sheets\nb. Gmail\nc. OpenAI (API Key)\nAssign these credentials to the respective nodes in the JSON.\n\n3. OpenAI Model:\nChoose a model like gpt-4o-mini (used here) or any other available in your plan.\nAdjust the prompt in the \"Generate Post Content\" node if needed.\n\n4. Email Configuration:\nIn the Gmail node, set the recipient email to your own or your team’s address.\nCustomize the email message template if necessary.\n\n5. Schedule the Workflow:\nSet the trigger interval (e.g., every morning at 9 AM).\n\n6. Testing:\nRun the workflow manually first to confirm everything works.\nCheck Gmail for the approval form, respond, and verify the results.",
+			"nodes": [
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.scheduleTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.linkedIn",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:langchain"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 87.21,
+			"scoreBreakdown": {
+				"traction": 0.668,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.769
+			},
+			"source": "https://n8n.io/workflows/4005",
+			"author": "shindearyan",
+			"success": true
+		},
+		{
+			"id": 5163,
+			"slug": "ai-powered-stock-analysis-assistant-with-telegram-claude-gpt-5163",
+			"name": "AI-Powered Stock Analysis Assistant with Telegram, Claude & GPT-4O Vision",
+			"description": "\"Ade Technical Analyst\" is a dual-workflow AI system combining conversational intelligence with visual chart analysis through Telegram. The system features 11 primary nodes for conversation management and 8 secondary nodes for chart generation and analysis.\n\nCore Components:\n\nTelegram Integration: Message handling with dynamic typing indicators\n\nAI Personality: \"Ade\" - a financial analyst with 50+ years NYSE/LSE experience using Claude 3.5 Sonnet\n\nChart Generation: TradingView integration via Chart-IMG API with MACD and volume indicators\n\nVisual Analysis: GPT-4O vision for technical pattern recognition\n\nMemory System: Session-based conversation context retention\n\nTarget Users\nIndividual traders seeking professional-grade analysis without subscription costs\n\nFinancial advisors wanting 24/7 AI-powered client support\n\nInvestment educators needing interactive learning tools\n\nFintech companies requiring white-label analysis solutions\n\nSetup Requirements\nCritical Security Fix Needed:\n\nRemove hardcoded API key from Chart-IMG node immediately\n\nStore all credentials securely in n8n credential manager\n\nRequired APIs:\n\nOpenRouter (Claude 3.5 Sonnet)\n\nOpenAI (GPT-4O vision)\n\nChart-IMG API\n\nTelegram Bot Token\n\nTechnical Prerequisites:\n\nn8n version 1.7+ with Langchain nodes\n\nWebhook configuration for Telegram\n\nDual-workflow setup with proper ID referencing\n\nWorkflow Requirements\nSecurity Compliance:\n\nNever hardcode API keys in workflow JSON files\n\nUse n8n credential manager for all sensitive data\n\nImplement proper session isolation for user data\n\nInclude mandatory financial disclaimers\n\nPerformance Specifications:\n\nModel temperature: 0.8 for balanced responses\n\nToken limit: 500 for optimized performance\n\nDark theme charts with professional indicators\n\nSession-based memory management\n\nNeed help customizing?\n[Contact](Contact) me for consulting and support  or add me on [LinkedIn](LinkedIn)",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.toolWorkflow",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.telegramTrigger",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:langchain"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 87.19,
+			"scoreBreakdown": {
+				"traction": 0.698,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.647
+			},
+			"source": "https://n8n.io/workflows/5163",
+			"author": "hgray",
+			"success": true
+		},
+		{
+			"id": 13526,
+			"slug": "generate-ai-videos-and-carousels-with-blotato-for-instagram--13526",
+			"name": "Generate AI videos and carousels with Blotato for Instagram and TikTok",
+			"description": "# Generate AI videos and carousels with Blotato and publish to Instagram & TikTok\n\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/Turn-AI-Videos-Carousels-Into-Income-with-n8n-Fully-Automated-x-Blotato-30c3d6550fd9804b999ede955fdf409d?source=copy_link)\n\n![Workflow Overview](https://www.dr-firas.com/blotato-agent.png)\n\n### Who is this for?\n\nThis workflow is designed for **content creators, marketers, solopreneurs, and automation enthusiasts** who want to generate and publish short-form content on **Instagram and TikTok** automatically.  \nIt is ideal for users looking to combine **AI-generated videos and carousels** with **Blotato** and orchestrate everything using **n8n**.\n\n---\n\n### What this workflow does\n\nThis workflow provides a complete **end-to-end automation pipeline**:\n\n1. Receives a message from **Telegram** containing a public URL and a publishing instruction.\n2. Creates a content source from the URL using **Blotato**.\n3. Retrieves and validates the extracted text content.\n4. Generates either:\n   - An **AI tweet-card carousel** for Instagram, or\n   - An **AI-generated video** for TikTok.\n5. Continuously checks the visual generation status until it is fully completed.\n6. Publishes the final media automatically to **Instagram or TikTok**.\n7. Sends a confirmation message back to Telegram once the post is successfully published.\n\n---\n\n### Setup\n\nTo use this workflow, you will need:\n\n- An active **n8n** instance\n- A **[Blotato](https://blotato.com/?ref=firas)** account with API access\n- Instagram and/or TikTok accounts connected in **[Blotato](https://blotato.com/?ref=firas)**\n- A **Telegram Bot** for triggering the workflow and receiving notifications\n\nSetup steps:\n1. Import the workflow JSON into n8n.\n2. Add your **[Blotato](https://blotato.com/?ref=firas)** API credentials.\n3. Configure the Telegram Trigger with your bot token.\n4. Select your Instagram and TikTok accounts in the **[Blotato](https://blotato.com/?ref=firas)** post nodes.\n5. Activate the workflow.\n\n---\n\n### How to customize this workflow to your needs\n\nYou can customize this workflow by:\n- Changing the visual templates used in Blotato.\n- Adjusting AI prompts to control tone, format, or content style.\n- Adding additional publishing platforms after the posting step.\n- Modifying polling behavior or adding timeouts for long visual renders.\n- Replacing Telegram with another trigger such as Webhooks or Slack.\n\nThe workflow is modular and easy to extend, making it suitable for a wide range of content automation use cases.\n\n\n### 🎥 [Watch This Tutorial](https://youtu.be/HaYFevp7KsU)\n\n![SORA2 logo](https://www.dr-firas.com/blotato-miniature.png)\n\n\n---\n### 👋 Need help or want to customize this?\n📩 Contact: [LinkedIn](https://www.linkedin.com/in/dr-firas/)  \n📺 YouTube: [@DRFIRASS](https://www.youtube.com/@DRFIRASS)  \n🚀 Workshops: [Mes Ateliers n8n](https://hotm.art/formation-n8n)\n\n\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https://www.youtube.com/channel/UCriIQI8uaoEro5FEnOpeidQ) / [🚀 Mes Ateliers n8n  ](https://hotm.art/formation-n8n)",
+			"nodes": [
+				"@blotato/n8n-nodes-blotato.blotatoTool",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.telegramTool",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:blotatoTool"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 87.06,
+			"scoreBreakdown": {
+				"traction": 0.728,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.5
+			},
+			"source": "https://n8n.io/workflows/13526",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 10640,
+			"slug": "scrape-google-maps-business-leads-with-apify-gpt-4-email-ext-10640",
+			"name": "Scrape Google Maps Business Leads with Apify & GPT-4 Email Extraction",
+			"description": "# 💥 Automate Scrape Google Maps Business Leads (Email, Phone, Website) using Apify\n\n![Workflow Overview](https://www.dr-firas.com/googlemaps.png)\n\n# 🧠 AI-Powered Business Prospecting Workflow (Google Maps + Email Enrichment)\n\n### Who is this for?\nThis workflow is designed for **entrepreneurs, sales teams, marketers, and agencies** who want to **automate lead discovery** and **build qualified business contact lists** — without manual searching or copying data.  \nIt’s perfect for anyone seeking an **AI-driven prospecting assistant** that saves time, centralizes business data, and stays fully **compliant with GDPR**.\n\n---\n\n### What problem is this workflow solving?\nManually searching for potential clients, copying their details, and qualifying them takes hours — and often leads to messy spreadsheets.  \nThis workflow **automates the process** by:\n- Gathering **publicly available business information** from Google Maps  \n- Enriching that data with **AI-powered summaries and contact insights**  \n- Compiling it into a clean, ready-to-use **Google Sheet database**\n\nThis means you can focus on **closing deals**, not collecting data.\n\n---\n\n### What this workflow does\nThis automation identifies, analyzes, and organizes business opportunities in just a few steps:\n1. **Telegram Trigger** → Send a message specifying your business type, number of leads, and Google Maps URL.  \n2. **Apify Integration** → Fetches business information from Google Maps (public data).  \n3. **Duplicate Removal** → Ensures clean, non-redundant results.  \n4. **AI Summarization (GPT-4)** → Generates concise business summaries for better understanding.  \n5. **Email Extraction (GPT-4)** → Finds and extracts professional contact emails from company websites.  \n6. **Google Sheets Integration** → Automatically stores results (name, category, location, phone, email, etc.) in a structured sheet.  \n7. **Telegram Notification** → Confirms when all businesses are processed.  \n\nAll data is handled ethically and transparently — only from **public sources** and without any unsolicited contact.\n\n---\n\n### Setup\n1. **Telegram Setup**  \n   - Create a Telegram bot via [BotFather](https://t.me/BotFather)  \n   - Copy the API token and paste it into the Telegram Trigger node credentials.  \n\n2. **Apify Setup**  \n   - Create an account on [Apify](https://www.apify.com?fpr=udemy)  \n   - Get your API token and connect it to the “Run Google Maps Scraper” node.  \n\n3. **Google Sheets Setup**  \n   - Connect your Google account under the “Google Maps Database” node.  \n   - Specify the target spreadsheet and worksheet name.  \n\n4. **OpenAI Setup**  \n   - Add your OpenAI API key to the AI nodes (“Company Summary Info” and “Extract Business Email”).  \n\n5. **Test**  \n   - Send a Telegram message like:  \n     `restaurants, 5, https://www.google.com/maps/search/restaurants+in+Paris`  \n\n---\n\n### How to customize this workflow to your needs\n- **Change search region or business type** by modifying the Telegram input message format.  \n- **Adjust the number of leads** via the `maxCrawledPlacesPerSearch` parameter in Apify.  \n- **Add filters or enrichments** (e.g., websites with social links, review counts, or opening hours).  \n- **Customize AI summaries** by tweaking the prompt inside the “Company Summary Info” node.  \n- **Integrate CRM tools** like HubSpot or Pipedrive by adding a connector after the Google Sheets node.  \n\n---\n\n### ⚙️ Expected Outcome\n✅ A clean, enriched, and ready-to-use **Google Sheet** of businesses with:  \n- Name, category, address, and city  \n- Phone number and website  \n- AI-generated business summary  \n- Extracted professional email (if available)  \n\n✅ Telegram confirmation once all businesses are processed  \n\n✅ Fully automated, scalable, and GDPR-compliant prospecting workflow  \n\n---\n\n💡 *This workflow provides a transparent, ethical way to streamline your B2B lead research while staying compliant with privacy and anti-spam regulations.*\n\n\n### 🎥 [Watch This Tutorial](https://youtu.be/cijBIHI6iLk)\n\n![Apify logo](https://www.dr-firas.com/apify.png)\n\n---\n### 👋 Need help or want to customize this?\n📩 Contact: [LinkedIn](https://www.linkedin.com/in/dr-firas/)  \n📺 YouTube: [@DRFIRASS](https://www.youtube.com/@DRFIRASS)  \n🚀 Workshops: [Mes Ateliers n8n](https://hotm.art/formation-n8n)\n\n---\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/Automate-Scrape-Google-Maps-Business-Leads-Email-Phone-Website-using-Apify-2a53d6550fd98118ba22e441171944dd?source=copy_link)\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https://www.youtube.com/channel/UCriIQI8uaoEro5FEnOpeidQ) / [🚀 Mes Ateliers n8n  ](https://hotm.art/formation-n8n)",
+			"nodes": [
+				"@apify/n8n-nodes-apify.apify",
+				"n8n-nodes-base.removeDuplicates",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:apify"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 86.91,
+			"scoreBreakdown": {
+				"traction": 0.649,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.786
+			},
+			"source": "https://n8n.io/workflows/10640",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 4587,
+			"slug": "extract-instagram-profile-data-with-apify-and-store-in-googl-4587",
+			"name": "Extract Instagram Profile Data with Apify and Store in Google Sheets",
+			"description": "\n## Workflow Overview\nThis cutting-edge n8n automation is a powerful social media intelligence gathering tool designed to transform Instagram profile research into a seamless, automated process. By intelligently combining web scraping, data formatting, and cloud storage technologies, this workflow:\n\n1. **Discovers Profile Insights**: \n   - Automatically scrapes Instagram profile data\n   - Captures comprehensive profile metrics\n   - Extracts critical social media intelligence\n\n2. **Intelligent Data Capture**:\n   - Retrieves follower counts\n   - Collects biographical information\n   - Captures profile picture and external links\n\n3. **Seamless Data Logging**:\n   - Automatically stores data in Google Sheets\n   - Creates a living, updateable database\n   - Enables easy analysis and tracking\n\n## Key Benefits\n- 🤖 **Full Automation**: Instant profile intelligence\n- 💡 **Comprehensive Insights**: Detailed social media metrics\n- 📊 **Effortless Tracking**: Automated data collection\n- 🌐 **Multi-Purpose Research**: Flexible data gathering\n\n## Workflow Architecture\n\n### 🔹 Stage 1: Trigger & Input\n- **Form-Based Trigger**: Manual username submission\n- **Webhook Support**: Flexible data entry methods\n- **User-Driven Initiation**\n\n### 🔹 Stage 2: Web Scraping\n- **Apify Integration**: Robust Instagram data extraction\n- **Comprehensive Profile Scanning**:\n  - Followers count\n  - Following count\n  - Profile biography\n  - Profile picture URL\n\n### 🔹 Stage 3: Data Formatting\n- **Intelligent Data Mapping**\n- **Standardized Data Structure**\n- **Preparation for Storage**\n\n### 🔹 Stage 4: Cloud Logging\n- **Google Sheets Integration**\n- **Persistent Data Storage**\n- **Easy Access and Analysis**\n\n## Potential Use Cases\n- **Influencer Marketing**: Talent identification\n- **Competitive Intelligence**: Audience research\n- **Social Media Analysis**: Performance tracking\n- **Recruitment**: Talent scouting\n- **Brand Partnerships**: Collaboration opportunities\n\n## Setup Requirements\n1. **Apify Account**\n   - Instagram scraping actor\n   - API token\n   - Configured scraping parameters\n\n2. **Google Sheets**\n   - Connected Google account\n   - Prepared tracking spreadsheet\n   - Appropriate sharing settings\n\n3. **n8n Installation**\n   - Cloud or self-hosted instance\n   - Workflow configuration\n   - API credential management\n\n## Future Enhancement Suggestions\n- 🤖 Advanced profile scoring\n- 📊 Engagement rate calculation\n- 🔔 Real-time change alerts\n- 🌐 Multi-platform profile tracking\n- 🧠 AI-powered insights generation\n\n## Technical Considerations\n- Implement robust error handling\n- Use exponential backoff for API calls\n- Maintain flexible data extraction strategies\n- Ensure compliance with platform terms of service\n\n## Ethical Guidelines\n- Respect user privacy\n- Use data for legitimate research\n- Maintain transparent data collection practices\n- Provide opt-out mechanisms\n\n\n## Connect With Me\n\n**Ready to unlock social media insights?**\n\n📧 **Email**: Yaron@nofluff.online\n\n🎥 **YouTube**: [@YaronBeen](https://www.youtube.com/@YaronBeen/videos)\n\n💼 **LinkedIn**: [Yaron Been](https://www.linkedin.com/in/yaronbeen/)\n\n**Transform your social media research with intelligent, automated workflows!**\n\n#InstagramDataScraping #SocialMediaIntelligence #InfluencerMarketing #DataAutomation #AIResearch #MarketingTechnology #SocialMediaAnalytics #ProfileIntelligence #WebScraping #MarketingTech\n",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:formTrigger", "integration:httpRequest"],
+			"triggerType": "formTrigger",
+			"hasAI": false,
+			"score": 86.9,
+			"scoreBreakdown": {
+				"traction": 0.595,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4587",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 7456,
+			"slug": "automate-cv-screening-with-ai-candidate-analysis-7456",
+			"name": "🤖 Automate CV Screening with AI Candidate Analysis",
+			"description": "## How it works\n\nThis workflow automates your initial hiring pipeline by creating an AI-powered CV scanner. It collects job applications through a web form, uses AI to analyze the candidate's CV against your job description, and neatly organizes the results in a Google Sheet.\n\nHere’s the step-by-step process:\n*   **The Application Form:** A `Form Trigger` provides a public web form for candidates to submit their name, email, and CV (as a PDF).\n*   **Initial Logging:** As soon as an application is submitted, the candidate's name and email are added to a Google Sheet. This ensures every applicant is logged, even if a later step fails.\n*   **CV Text Extraction:** The workflow uses **Mistral's OCR** model to accurately extract all the text from the uploaded CV PDF.\n*   **AI Analysis:** The extracted text is sent to **Google Gemini**. A detailed prompt instructs the AI to act as a hiring assistant, scoring the CV against the specific requirements of your job role and providing a detailed explanation for its score.\n*   **Structured Output:** A `JSON Output Parser` ensures the AI's analysis is returned in a clean, structured format, making the data reliable.\n*   **Final Record:** The AI-generated qualification score and explanation are added to the candidate's row in the Google Sheet, giving you a complete, analyzed list of applicants.\n\n### Set up steps\n\n**Setup time: ~15 minutes**\n\nYou'll need API keys for Mistral and Google AI, and to connect your Google account.\n\n1.  **Get Your Mistral API Key:**\n    *   Visit the Mistral Platform at [console.mistral.ai/api-keys](https://console.mistral.ai/api-keys).\n    *   Create and copy your API key.\n    *   In the workflow, go to the **`Extract CV Text`** node, click the **Credential** dropdown, and select **`+ Create New Credential`**.\n    *   Paste your key into the **API Key** field and **Save**.\n\n2.  **Get Your Google AI API Key:**\n    *   Visit Google AI Studio at [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey).\n    *   Click **\"Create API key in new project\"** and copy the key.\n    *   In the workflow, go to the **`Gemini 2.5 Flash Lite`** node, click the **Credential** dropdown, and select **`+ Create New Credential`**.\n    *   Paste your key into the **API Key** field and **Save**.\n\n3.  **Connect Your Google Account:**\n    *   Select the **`Create 'CVs' Spreadsheet`** node.\n    *   Click the **Credential** dropdown and select **`+ Create New Credential`** to connect your Google account.\n    *   Repeat this for the **`Log Candidate Submission`** and **`Add CV Analysis`** nodes, selecting the credential you just created.\n\n4.  **Create Your Spreadsheet:**\n    *   Click the \"play\" icon on the **`Start Here`** node to run it. This will create a new Google Sheet in your Google Drive named \"CVs\" with the correct columns.\n\n5.  **Customize the Job Role:**\n    *   Go to the **`AI Qualification`** node.\n    *   In the **Text** parameter, find the `job_requirements` section and replace the example job description with your own. Be as detailed as possible for the best results.\n\n6.  **Start Screening!**\n    *   Activate the workflow using the toggle at the top right.\n    *   Go to the **`Application Form`** node and click the **\"Open Form URL\"** button.\n    *   Fill out the form with a test application and upload a sample CV. Check your Google Sheet to see the AI's analysis appear within moments",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.mistralAi",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.chainLlm"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:googleSheets"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 86.88,
+			"scoreBreakdown": {
+				"traction": 0.649,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.778
+			},
+			"source": "https://n8n.io/workflows/7456",
+			"author": "lucaspeyrin",
+			"success": true
+		},
+		{
+			"id": 5541,
+			"slug": "track-ai-agent-token-usage-and-estimate-costs-in-google-shee-5541",
+			"name": "Track AI Agent token usage and estimate costs in Google Sheets",
+			"description": "![image.png](fileId:1659)\n### This n8n template demonstrates how to obtain token usage from AI Agents and places the data into a spreadsheet that calculates the estimated cost of the execution.\n\nObtaining the token usage from AI Agents is tricky, because it doesn't provide all the data from tool calls. This workflow taps into the workflow execution metadata to extract token usage information.\n\nWorks well with OpenAI, Google and Anthropic. Other LLM providers might need small tweaks.\n\n### How it works\n1. The AI Agent executes and then calls a subworkflow to calculate the token usage.\n2. The data is stored in Google Sheets\n3. The spreadsheet has formulas to calculate the estimated cost of the execution.\n\n### How to use\n- The AI Agent is used as an example. Feel free to replace this with other agents you have.\n- Call the subworkflow AFTER all the other branches have finished executing.\n\n### Requirements\n- LLM account (OpenAI, Gemini...) for API usage.\n- Google Drive and Sheets credentials\n- n8n API key of your instance",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.executeWorkflow",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.toolThink",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.n8n",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.summarize",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.lmChatAnthropic"
+			],
+			"tags": ["trigger:manual", "ai", "integration:langchain"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.82,
+			"scoreBreakdown": {
+				"traction": 0.591,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5541",
+			"author": "solomon",
+			"success": true
+		},
+		{
+			"id": 5407,
+			"slug": "learn-code-node-javascript-with-an-interactive-hands-on-tuto-5407",
+			"name": "🎓 Learn Code Node (JavaScript) with an Interactive Hands-On Tutorial",
+			"description": "## How it works\n\nThis workflow is a hands-on tutorial for the **Code node** in n8n, covering both basic and advanced concepts through a simple data processing task.\n\n1.  **Provides Sample Data:** The workflow begins with a sample list of users.\n2.  **Processes Each Item (`Run Once for Each Item`):** The first Code node iterates through each user to calculate their `fullName` and `age`. This demonstrates basic item-by-item data manipulation using `$input.item.json`.\n3.  **Fetches External Data (Advanced):** The second Code node showcases a more advanced feature. For each user, it uses the built-in `this.helpers.httpRequest` function to call an external API (genderize.io) to enrich the data with a predicted gender.\n4.  **Processes All Items at Once (`Run Once for All Items`):** The third Code node receives the fully enriched list of users and runs only once. It uses `$items()` to access the entire list and calculate the `averageAge`, returning a single summary item.\n5. **Create a Binary File:** The final Code node gets the fully enriched list of users once again and creates a binary CSV file to show how to use binary data `Buffer` in JavaScript.\n\n## Set up steps\n\n**Setup time: &lt; 1 minute**\n\nThis workflow is a self-contained tutorial and requires no setup.\n\n1.  **Explore the Nodes:** Click on each of the Code nodes to read the code and the comments explaining each step, from basic to advanced.\n2.  **Run the Workflow:** Click \"Execute Workflow\" to see it in action.\n3.  **Check the Output:** Click on each node after the execution to see how the data is transformed at each stage. Notice how the data is progressively enriched.\n4.  **Experiment!** Try changing the data in the `1. Sample Data` node, or modify the code in the Code nodes to see what happens.",
+			"nodes": [
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger"
+			],
+			"tags": ["trigger:manual", "integration:code"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 86.71,
+			"scoreBreakdown": {
+				"traction": 0.692,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.571
+			},
+			"source": "https://n8n.io/workflows/5407",
+			"author": "lucaspeyrin",
+			"success": true
+		},
+		{
+			"id": 5924,
+			"slug": "ai-research-assistant-via-telegram-gpt-4o-mini-deepseek-r1-s-5924",
+			"name": "AI Research Assistant via Telegram (GPT-4o mini + DeepSeek R1 + SerpAPI)",
+			"description": "## AI Research Assistant via Telegram (GPT-4o mini + DeepSeek R1 + SerpAPI)\n\n\n\n## 👥 Who’s it for\n\nThis workflow is perfect for anyone who wants to receive AI-powered research summaries directly on Telegram. Ideal for people asking frequent product, tech, or decision-making questions and want up-to-date answers sourced from the web.\n\n## 🤖 What it does\n\nUsers send a question via Telegram. An AI agent (DeepSeek R1) reformulates and understands the intent, while a second agent (GPT-4o mini) performs live research using SerpAPI. The most relevant answers, including links and images, are delivered back via Telegram.\n\n \n## ⚙️ How it works\n\n📲 Telegram Trigger – Starts when a user sends a message to your Telegram bot.\n🧠 DeepSeek R1 Agent – Understands, clarifies, or reformulates the user query.\n🧠 Research AI Agent (GPT-4o mini + SerpAPI) – Searches the web and summarizes the best results.\n📤 Send Telegram Message – Sends the response back to the same user.\n\n## 📋 Requirements\n\n- Telegram bot (via BotFather) with API token set in n8n credentials\n\n- OpenAI account with API key and balance for GPT-4o mini\n\n- SerpAPI account (100 free searches/month) with API key\n\n- DeepSeek account with API key and balance\n\n\n\n## 🛠️ How to set up\n\nCreate your Telegram bot using BotFather and connect it using the Telegram Trigger node\nSet up DeepSeek credentials and add a Chat Model AI Agent node using DeepSeek R1 to reformulate the user’s question\nSet up OpenAI credentials and add a second ChatGPT AI Agent node using GPT-4o mini\nIn the GPT-4o node, enable the SerpAPI Tool and add your SerpAPI API key\nPass the reformulated question from DeepSeek to the GPT-4o agent for live search and summarization\nFormat the response (text, links, optional images)\nSend the final reply to the user using the Telegram Send Message node\nEnsure your n8n instance is publicly accessible\nTest the workflow by sending a message to your Telegram bot ✅\n",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatDeepSeek",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.toolSerpApi",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:langchain"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 86.62,
+			"scoreBreakdown": {
+				"traction": 0.612,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.875
+			},
+			"source": "https://n8n.io/workflows/5924",
+			"author": "arlindeveloper",
+			"success": true
+		},
+		{
+			"id": 4557,
+			"slug": "intelligent-email-organization-with-ai-powered-content-class-4557",
+			"name": "Intelligent Email Organization with AI-Powered Content Classification for Gmail",
+			"description": "This workflow leverages AI to intelligently analyze incoming Gmail messages and automatically apply relevant labels based on the email content.\n\nThe default configuration includes the following labels:\n\n* **Newsletter**: Subscription updates or promotional content.\n* **Inquiry**: Emails requesting information or responses.\n* **Invoice**: Billing and payment-related emails.\n* **Proposal**: Business offers or collaboration opportunities.\n* **Action Required**: Emails demanding immediate tasks or actions.\n* **Follow-up Reminder**: Emails prompting follow-up actions.\n* **Task**: Emails containing actionable tasks.\n* **Personal**: Non-work-related emails.\n* **Urgent**: Time-sensitive or critical communications.\n* **Bank**: Banking alerts and financial statements.\n* **Job Update**: Recruitment or job-related communications.\n* **Spam/Junk**: Unwanted or irrelevant bulk emails.\n* **Social/Networking**: Notifications from social platforms.\n* **Receipt**: Purchase confirmations and receipts.\n* **Event Invite**: Invitations or calendar-related messages.\n* **Subscription Renewal**: Reminders for subscription expirations.\n* **System Notification**: Technical alerts from services or systems.\n\nYou can customize labels and definitions based on your specific use case.\n\n### How it works:\n\n* The workflow periodically retrieves new Gmail messages.\n* Only emails without existing labels, regardless of read status, are sent to the AI for analysis.\n* Email content (subject and body) is analyzed by an AI model to determine the appropriate label.\n* Labels identified by the AI are applied to each email accordingly.\n\n**Note:** This workflow performs 100% better than the default Gmail trigger method, which is why the workflow was switched from Gmail trigger to a scheduled workflow. By selectively processing only unlabeled emails, it ensures comprehensive labeling while significantly reducing AI processing costs.\n\n### Setup Steps:\n\n1. Configure credentials for Gmail and your chosen AI service (e.g., OpenAI).\n2. Ensure labels exist in your Gmail account matching the workflow definitions.\n3. Adjust the AI prompt to match your labeling needs.\n4. Optionally customize the polling interval (default: every 2 minutes).\n\nThis workflow streamlines your email management, keeping your inbox organized effortlessly while optimizing resource usage.\n",
+			"nodes": [
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.noOp",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.compareDatasets",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.code"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:gmail"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 86.6,
+			"scoreBreakdown": {
+				"traction": 0.668,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.647
+			},
+			"source": "https://n8n.io/workflows/4557",
+			"author": "niranjan",
+			"success": true
+		},
+		{
+			"id": 3016,
+			"slug": "invoices-from-gmail-to-drive-and-google-sheets-3016",
+			"name": "Invoices from Gmail to Drive and Google Sheets",
+			"description": "# Attachments Gmail to Drive and Google Sheets\n\n## Description\nAutomatically process invoice emails by saving attachments to Google Drive and extracting key invoice data to Google Sheets using AI. This workflow monitors your Gmail for unread emails with attachments, saves PDFs to a specified Google Drive folder, and uses OpenAI's GPT-4o to extract invoice details (date, description, amount) into a structured spreadsheet.\n\n## Use cases\n- **Invoice Management**: Automatically organize and track invoices received via email\n- **Financial Record Keeping**: Maintain a structured database of all invoice information\n- **Document Organization**: Keep digital copies of invoices organized in Google Drive\n- **Automated Data Entry**: Eliminate manual data entry for invoice processing\n\n## Resources\n- Gmail account\n- Google Drive account\n- Google Sheets account\n- OpenAI API key\n\n## Setup instructions\n\n### Prerequisites\n1. Active Gmail, Google Drive, and Google Sheets accounts\n2. OpenAI API key (GPT-4o model access)\n3. n8n instance with credentials manager\n\n### Steps\n1. **Gmail and Google Drive Setup**:\n   - Connect your Gmail account in n8n credentials\n   - Connect your Google Drive account with appropriate permissions\n   - Create a destination folder in Google Drive for invoice storage\n\n2. **Google Sheets Setup**:\n   - Connect your Google Sheets account\n   - Create a spreadsheet with columns: Invoice date, Invoice Description, Total price, and Fichero\n   - Copy your spreadsheet ID for configuration\n\n3. **OpenAI Setup**:\n   - Add your OpenAI API key to n8n credentials\n\n4. **Configure Email Filter**:\n   - Update the email filter node to match your specific sender requirements\n\n## Benefits\n- **Time Saving**: Eliminates manual downloading, filing, and data entry\n- **Accuracy**: AI-powered data extraction reduces human error\n- **Organization**: Consistent file naming and storage structure\n- **Searchability**: Creates a searchable database of all invoice information\n- **Automation**: Runs every minute to process new emails as they arrive\n\n## Related templates\n- Email Parser to CRM\n- Document Processing Workflow\n- Financial Data Automation",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.gmailTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.extractFromFile",
+				"@n8n/n8n-nodes-langchain.lmOpenAi",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.if"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:googleDrive"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 86.59,
+			"scoreBreakdown": {
+				"traction": 0.633,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.786
+			},
+			"source": "https://n8n.io/workflows/3016",
+			"author": "carlosgracia",
+			"success": true
+		},
+		{
+			"id": 5024,
+			"slug": "build-custom-workflows-automatically-with-gpt-4o-rag-and-web-5024",
+			"name": "Build Custom Workflows Automatically with GPT-4o, RAG, and Web Search",
+			"description": "## 🚀 What the “Agent Builder” template does\n\nNeed to **turn a one-line chat request into a fully-wired n8n workflow template—complete with AI agents, RAG, and web-search super-powers—without lifting a finger?**\nThat’s exactly what *Agent Builder* automates:\n\n1. **Listens to any incoming chat message** (via the *Chat Trigger*).\n2. **Spins up an AI architect** that analyses the request, searches the web, reads n8n docs from a Pinecone vector store, and designs the smallest possible set of nodes.\n3. **Auto-generates a ready-to-import JSON template** and hands it back as a downloadable file—plus all the supporting assets (embeddings, vector store etc.) so the next prompt is even smarter.\n\nThink of it as your personal “workflow chef”: you shout the order, it shops for ingredients, cooks, plates, and serves the meal. All you do is eat.\n\n---\n\n## 🤗 Who will love this?\n\n* **No-code builders / power users** who don’t want to wrestle with AI node wiring.\n* **Agencies & consultants** delivering lots of bespoke automations.\n* **Internal platform teams** who need a “workflow self-service portal” for non-technical colleagues.\n\n---\n\n## 🧩 How it’s wired\n\n| Sub-process                | What happens inside                                                                                                                                                                              | Key nodes                                                                              |\n| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------- |\n| **Web Crawler** (optional) | Firecrawl scrapes docs.n8n.io (or any URL you drop in) and streams raw markdown back.                                                                                                            | `Set URL → HTTP Request (Extract) → Wait & Retry`                                      |\n| **RAG Trainer**            | Splits the scraped docs, embeds them with OpenAI, and upserts vectors into Pinecone.                                                                                                             | `Recursive Text Splitter → Embeddings OpenAI → Train Pinecone`                         |\n| **Agent Builder**          | The star of the show – orchestrates GPT-4o (via OpenRouter), SerpAPI web-search, your Pinecone index and a Structured Output Parser to **produce → validate → prettify** the final n8n template. | `Chat Trigger → AI Agent → OpenAI (validator) → Code (extract) → Convert to JSON file` |\n\n*Every arrow in the drawn workflow is pre-connected, so the generated template always passes n8n’s import check.*\n\n---\n\n## 🛠️ Getting set up (5 quick creds)\n\n| Service                                             | Credential type                                            |\n| --------------------------------------------------- | ---------------------------------------------------------- |\n| **OpenAI / Azure OpenAI** – embeddings & validation | *OpenAI API*                                               |\n| **Pinecone** – vector store                         | *Pinecone API*                                             |\n| **OpenRouter** – GPT-4o LLM                         | *OpenRouter API Key*                                       |\n| **SerpAPI** – web search                            | *SerpAPI Key*                                              |\n| **Firecrawl** (only if you plan to crawl)           | Generic **Header Auth** → `Authorization: Bearer YOUR_KEY` |\n\nEach node already expects those creds; just create them once, select in the dropdown, hit **Activate**.\n\n---\n\n## 🏃‍♀️ What a typical run looks like\n\n1. **User says:** “Build me a workflow that monitors our support inbox, summarises new tickets with GPT and posts to Slack.”\n2. *Chat Trigger* captures the message.\n3. **AI Agent**:\n\n   * queries Pinecone for relevant n8n docs,\n   * fires a SerpAPI search for “n8n gmail trigger example”,\n   * sketches an architecture (Gmail Trigger → GPT Model → Slack).\n4. The agent **returns JSON** ➜ OpenAI node double-checks field names, connections, type versions.\n5. A tiny JS Code node slices the JSON out of the chat blob and **saves it as `template.json`** ready for download.\n6. You download, import, and… done.\n\n---\n\n## ✏️ Customising\n\n* **Switch the LLM** – plug in Claude 3, Gemini 1.5, or a local model; just swap the *OpenRouter Chat Model* node.\n* **Point the RAG at your own docs** – change the crawl URL or feed PDFs via the *Default Data Loader*.\n* **Hard-code preferred nodes** – edit the “User node preferences” in the system message so the agent always chooses *Notion* for databases, etc.\n\n---\n\n## 🥡 Take-away notes\n\n* It's a **prototype** feel free to experiment with it to improve its capabilities.\n* **Have fun building!**\n",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.wait",
+				"@n8n/n8n-nodes-langchain.toolSerpApi",
+				"@n8n/n8n-nodes-langchain.vectorStorePinecone",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.convertToFile",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:langchain"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 86.56,
+			"scoreBreakdown": {
+				"traction": 0.654,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.696
+			},
+			"source": "https://n8n.io/workflows/5024",
+			"author": "agents-by-franz",
+			"success": true
+		},
+		{
+			"id": 3086,
+			"slug": "publish-wordpress-posts-to-social-media-x-facebook-linkedin--3086",
+			"name": "Publish WordPress Posts to Social Media X, Facebook, LinkedIn, Instagram with AI",
+			"description": "### Workflow Description for n8n: Social Media Post from Ideas Copy\n\nThis workflow automates the process of creating and publishing **social media posts** across multiple platforms (Twitter/X, Facebook, LinkedIn, and Instagram) based on content from a WordPress post. It uses **AI models** to generate platform-specific captions and images, and integrates with **Google Sheets**, **WordPress**, and various social media APIs. \n\nIs a powerful tool for automating social media post creation and publishing, saving time and ensuring consistent, platform-optimized content across multiple channels.\n\nBelow is a breakdown of the workflow:\n\n---\n\n#### **1. How It Works**\nThe workflow is designed to streamline the creation and publishing of social media posts. Here's how it works:\n\n1. **Trigger**:\n   - The workflow starts with a **Manual Trigger** node, which initiates the process when the user clicks \"Test workflow.\"\n\n2. **Fetch Data**:\n   - The **Google Sheets** node retrieves the **WordPress Post ID** from a predefined Google Sheet.\n   - The **Get Post** node fetches the corresponding WordPress post content using the retrieved Post ID.\n\n3. **Generate Social Media Content**:\n   - The **Social Media Manager** node uses an **AI model (OpenRouter)** to analyze the WordPress post and generate platform-specific captions for **Twitter/X**, **Facebook**, **LinkedIn**, and **Instagram**.\n   - The AI ensures that each caption is tailored to the platform's audience, tone, and style, including hashtags and calls to action.\n\n4. **Generate Images**:\n   - The **Image Instagram** and **Image Facebook e Linkedin** nodes use **OpenAI** to generate platform-specific images for Instagram, Facebook, and LinkedIn posts.\n\n5. **Publish on Social Media**:\n   - The workflow publishes the generated content and images on the respective platforms:\n     - **Publish on X**: Posts the caption on Twitter/X.\n     - **Publish on LinkedIn**: Posts the caption and image on LinkedIn.\n     - **Publish on Facebook**: Posts the caption and image on Facebook.\n     - **Publish on Instagram**: Posts the caption and image on Instagram.\n\n6. **Update Google Sheets**:\n   - The workflow updates the Google Sheet to mark the posts as published (e.g., \"X OK,\" \"Facebook OK,\" \"LinkedIn OK,\" \"Instagram OK\").\n\n---\n\n#### **2. Set Up Steps**\nTo set up and use this workflow in n8n, follow these steps:\n\n1. **Google Sheets Setup**:\n   - Create (or clone) a Google Sheet with columns for **POST ID**, **TEXT**, **TWITTER**, **FACEBOOK**, **INSTAGRAM**, and **LINKEDIN**.\n   - Link the Google Sheet to the **Google Sheets** node by providing the **Document ID** and **Sheet Name**.\n\n2. **WordPress Integration**:\n   - Set up WordPress credentials in n8n for the **Get Post** node.\n   - Ensure the WordPress site is accessible via its REST API.\n\n3. **AI Model Configuration**:\n   - Configure the **OpenRouter** credentials in n8n for the **Social Media Manager** node.\n   - Ensure the AI model is set up to generate platform-specific captions.\n\n4. **Image Generation**:\n   - Set up **OpenAI** credentials for the **Image Instagram** and **Image Facebook e Linkedin** nodes to generate images.\n\n5. **Social Media API Integration**:\n   - Set up credentials for each social media platform:\n     - **Twitter/X**: Configure the **Publish on X** node with Twitter OAuth2 credentials.\n     - **LinkedIn**: Configure the **Publish on LinkedIn** node with LinkedIn OAuth2 credentials.\n     - **Facebook**: Configure the **Publish on Facebook** and **Publish on Instagram** nodes with Facebook Graph API credentials.\n\n6. **Test the Workflow**:\n   - Click the **\"Test workflow\"** button in n8n to trigger the workflow.\n   - The workflow will:\n     - Fetch the WordPress post content.\n     - Generate platform-specific captions and images.\n     - Publish the posts on Twitter/X, Facebook, LinkedIn, and Instagram.\n     - Update the Google Sheet to mark the posts as published.\n\n7. **Optional Customization**:\n   - Modify the workflow to include additional platforms or customize the AI-generated content further.\n\n\n---\n\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.wordpress",
+				"n8n-nodes-base.twitter",
+				"n8n-nodes-base.linkedIn",
+				"n8n-nodes-base.facebookGraphApi",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:manual", "ai", "integration:googleSheets"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.55,
+			"scoreBreakdown": {
+				"traction": 0.655,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.688
+			},
+			"source": "https://n8n.io/workflows/3086",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4400,
+			"slug": "build-a-pdf-document-rag-system-with-mistral-ocr-qdrant-and--4400",
+			"name": "Build a PDF Document RAG System with Mistral OCR, Qdrant and Gemini AI",
+			"description": "This workflow is designed to **process PDF documents** using **Mistral's OCR** capabilities, store the extracted text in a Qdrant vector database, and enable Retrieval-Augmented Generation (**RAG**) for answering questions. Here’s how it functions:  \n\nOnce configured, the workflow automates document ingestion, vectorization, and intelligent querying, enabling powerful RAG applications.\n\n---\n\n### **Benefits**\n\n* **End-to-End Automation**\n  No manual interaction is needed: documents are read, processed, and made queryable with minimal setup.\n\n* **Scalable and Modular**\n  The workflow uses subflows and batching, making it easy to scale and customize.\n\n* **Multi-Model Support**\n  Combines Mistral for OCR, OpenAI for embeddings, and Gemini for intelligent answering—taking advantage of the strengths of each.\n\n* **Real-Time Q\\&A**\n  With RAG integration, users can query document content through natural language and receive accurate responses grounded in the PDF data.\n\n* **Light or Full Mode**\n  Users can choose to index full page content or only summarized text, optimizing for either performance or richness.\n\n---\n\n### **How It Works** \n\n1. **PDF Processing with Mistral OCR**:  \n   - The workflow starts by uploading a PDF file to Mistral's API, which performs OCR to extract text and metadata.  \n   - The extracted content is split into manageable chunks (e.g., pages or sections) for further processing.  \n\n2. **Vector Storage in Qdrant**:  \n   - The extracted text is converted into embeddings using OpenAI's embedding model.  \n   - These embeddings are stored in a Qdrant vector database, enabling efficient similarity searches for RAG.  \n\n3. **Question-Answering with RAG**:  \n   - When a user submits a question via a chat interface, the workflow retrieves relevant text chunks from Qdrant using vector similarity.  \n   - A language model (Google Gemini) generates answers based on the retrieved context, providing accurate and context-aware responses.  \n\n4. **Optional Summarization**:  \n   - The workflow includes an optional summarization step using Google Gemini to condense the extracted text for faster processing or lighter RAG usage.  \n\n---\n\n### **Set Up Steps**  \nTo deploy this workflow in n8n, follow these steps:  \n\n1. **Configure Qdrant Database**:  \n   - Replace `QDRANTURL` and `COLLECTION` in the \"Create collection\" and \"Refresh collection\" nodes with your Qdrant instance details.  \n   - Ensure the Qdrant collection is configured with the correct vector size (e.g., 1536 for OpenAI embeddings) and distance metric (e.g., Cosine).  \n\n2. **Set Up Credentials**:  \n   - Add credentials for:  \n     - **Mistral Cloud API** (for OCR processing).  \n     - **OpenAI API** (for embeddings).  \n     - **Google Gemini API** (for chat and summarization).  \n     - **Google Drive** (if sourcing PDFs from Drive).  \n     - **Qdrant API** (for vector storage).  \n\n3. **PDF Source Configuration**:  \n   - If using Google Drive, specify the folder ID in the \"Search PDFs\" node.  \n   - Alternatively, modify the workflow to accept PDFs from other sources (e.g., direct uploads or external APIs).  \n\n4. **Customize Text Processing**:  \n   - Adjust chunk size and overlap in the \"Token Splitter\" node to optimize for your document type.  \n   - Choose between raw text or summarized content for RAG by toggling between the \"Set page\" and \"Summarization Chain\" nodes.  \n\n5. **Test the RAG**:  \n   - Trigger the workflow manually or via a chat message to verify OCR, embedding, and Qdrant storage.  \n   - Use the \"Question and Answer Chain\" node to test query responses.  \n\n6. **Optional Sub-Workflows**:  \n   - The workflow supports execution as a sub-workflow for batch processing (e.g., handling multiple PDFs).  \n\n----\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.splitInBatches",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterTokenSplitter",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.chainRetrievalQa",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.retrieverVectorStore",
+				"@n8n/n8n-nodes-langchain.vectorStoreQdrant",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.executeWorkflow",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.chainSummarization",
+				"n8n-nodes-base.googleDrive"
+			],
+			"tags": ["trigger:manual", "ai", "integration:langchain"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.5,
+			"scoreBreakdown": {
+				"traction": 0.67,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.621
+			},
+			"source": "https://n8n.io/workflows/4400",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 3904,
+			"slug": "search-linkedin-companies-score-with-ai-and-add-them-to-goog-3904",
+			"name": "Search LinkedIn companies, Score with AI and add them to Google Sheet CRM",
+			"description": "# Search LinkedIn companies, Score with AI and add them to Google Sheet CRM\n\n**Setup Video: [https://youtube.com/watch?v=m904RNxtF0w&t](https://youtube.com/watch?v=m904RNxtF0w&t)**\n\n### Who is this for?\nThis template is ideal for sales teams, business development professionals, and marketers looking to build a targeted prospect database with automatic qualification. Perfect for agencies, consultants, and B2B companies wanting to identify and prioritize the most promising potential clients.\n\n### What problem does this workflow solve?\nManually researching companies on LinkedIn, evaluating their fit for your services, and tracking them in your CRM is time-consuming and subjective. This automation streamlines lead generation by automatically finding, scoring, and importing qualified prospects into your database.\n\n### What this workflow does\nThis workflow automatically searches for companies on LinkedIn based on your criteria, retrieves detailed information about each company, filters them based on quality indicators, uses AI to score how well they match your ideal customer profile, and adds them to your Google Sheet CRM while preventing duplicates.\n\n### Setup\n1. Create a Ghost Genius API account and get your API key\n2. Configure HTTP Request nodes with Header Auth credentials\n3. Create a copy of the provided Google Sheet template\n4. Set up your Google Sheet and OpenAI credentials following n8n documentation\n5. Customize the \"Set Variables\" node to match your target audience and scoring criteria\n\n### How to customize this workflow\n- Modify search parameters to target different industries, locations, or company sizes\n- Adjust the follower count threshold based on your qualification criteria\n- Customize the AI scoring system to align with your specific product or service offering\n- Add notification nodes to alert you when high-scoring companies are identified",
+			"nodes": [
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.manualTrigger"
+			],
+			"tags": ["trigger:manual", "ai", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.47,
+			"scoreBreakdown": {
+				"traction": 0.636,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.75
+			},
+			"source": "https://n8n.io/workflows/3904",
+			"author": "yaznow",
+			"success": true
+		},
+		{
+			"id": 2894,
+			"slug": "upload-to-instagram-tiktok-youtube-from-google-drive-2894",
+			"name": "Upload to Instagram, TikTok & YouTube from Google Drive",
+			"description": "## Description\nThis automation template is designed for content creators, digital marketers, and social media managers looking to simplify their video posting workflow. It automates the process of generating engaging video descriptions and uploading content to both Instagram and TikTok, making your social media management more efficient and error-free.\n\n### Who Is This For?\n- **Content Creators & Influencers:** Streamline your video uploads and focus more on creating content.\n- **Digital Marketers:** Ensure consistent posting across multiple platforms with minimal manual intervention.\n- **Social Media Managers:** Automate repetitive tasks and maintain a steady online presence.\n\n### What Problem Does This Workflow Solve?\nManually creating descriptions and uploading videos to different platforms can be time-consuming and error-prone. This workflow addresses these challenges by:\n- **Automating Video Uploads:** Monitors a designated Google Drive folder for new videos.\n- **Generating Descriptions:** Uses OpenAI to transcribe video audio and generate engaging, customized social media descriptions.\n- **Ensuring Multi-Platform Consistency:** Simultaneously posts your video with the generated description to Instagram and TikTok.\n- **Error Notifications:** Optional Telegram integration sends alerts in case of issues, ensuring smooth operations.\n\n### How It Works\n1. **Video Upload:** Place your video in the designated Google Drive folder.\n2. **Description Generation:** The automation triggers OpenAI to transcribe your video’s audio and generate a captivating description.\n3. **Content Distribution:** Automatically uploads the video and description to both Instagram and TikTok.\n4. **Error Handling:** Sends Telegram notifications if any issues arise during the process.\n\n### Setup\n1. Generate an API token at [social media API upload-post](https://upload-post.com) and configure it in both the Upload to TikTok and Upload to Instagram nodes.\n2. **Google Cloud Project:** Create a project in Google Cloud Platform, enable the Google Drive API, and generate the necessary OAuth credentials to connect to your Google Drive account.\n3. Set up your Google Drive folder in the Google Drive Trigger node.\n4. Customize the OpenAI prompt in the Generate Social Description node to match your brand’s tone.\n5. (Optional) Configure Telegram credentials for error notifications.\n\n### Requirements\n- **Accounts:** upload-post.com, Google Drive, and (optionally) Telegram.\n- **API Keys & Credentials:** Upload-post.com API token, OpenAI API key, and (optional) Telegram bot token.\n- **Google Cloud:** A project with the Google Drive API enabled and valid OAuth credentials.\n\nUse this template to enhance your productivity, maintain consistency across your social media channels, and engage your audience with high-quality video content.\n",
+			"nodes": [
+				"n8n-nodes-base.googleDriveTrigger",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.errorTrigger",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.writeBinaryFile",
+				"n8n-nodes-base.readBinaryFile",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:other", "ai", "integration:readBinaryFile"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 86.47,
+			"scoreBreakdown": {
+				"traction": 0.663,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.643
+			},
+			"source": "https://n8n.io/workflows/2894",
+			"author": "carlosgracia",
+			"success": true
+		},
+		{
+			"id": 4376,
+			"slug": "extract-invoice-data-from-email-to-google-sheets-using-gpt-4-4376",
+			"name": "Extract Invoice Data from Email to Google Sheets using GPT-4o AI Automation",
+			"description": "\nTransform your invoice processing from manual data entry into an intelligent automation system. This powerful n8n workflow monitors Gmail for invoice attachments, extracts data using AI-powered analysis, and creates organized Google Sheets with all relevant financial information automatically structured and ready for your accounting workflows.\n\n## 🔄 How It Works\n\nThis sophisticated 8-step automation eliminates manual invoice processing:\n\n**Step 1: Intelligent Email Monitoring**\nThe workflow continuously monitors your Gmail account for emails with specific labels, checking every minute for new invoice attachments that need processing.\n\n**Step 2: Attachment Verification**\nSmart filtering ensures only emails with PDF attachments are processed, preventing unnecessary workflow triggers from text-only emails.\n\n**Step 3: Advanced PDF Extraction**\nThe system automatically downloads and converts PDF invoices into readable text, handling various invoice formats and layouts with high accuracy.\n\n**Step 4: AI-Powered Data Analysis**\nGPT-4 processes the extracted text using specialized prompts designed for financial document analysis, identifying and extracting:\n- Company information and contact details\n- Invoice numbers, dates, and payment terms\n- Detailed line items with quantities and pricing\n- Tax calculations including CGST, SGST, and VAT\n- Billing and shipping addresses\n- Payment methods and transaction references\n\n**Step 5: Structured Data Formatting**\nThe AI output is automatically formatted into clean, consistent JSON structure with 25+ standardized fields for comprehensive invoice tracking.\n\n**Step 6: Dynamic Spreadsheet Creation**\nEach processed invoice generates a new Google Sheets document with timestamp naming and organized data layout, ready for accounting review.\n\n**Step 7: Automated File Organization**\nProcessed spreadsheets are automatically moved to designated Google Drive folders, maintaining organized file structure for easy retrieval and audit trails.\n\n**Step 8: Data Population**\nAll extracted invoice data is populated into the spreadsheet with proper formatting, formulas, and structure for immediate use in accounting workflows.\n\n## ⚙️ Setup Steps\n\n### Prerequisites\n- Gmail account with invoice-receiving capability\n- Google Workspace access for Sheets and Drive\n- OpenAI API account for data extraction\n- n8n instance (cloud or self-hosted)\n- PDF invoices (text-based, not scanned images)\n\n### Gmail Configuration Requirements\n\n**Label Setup:**\nCreate specific Gmail labels for invoice processing:\n```\n📧 Labels to Create:\n- \"Invoice-Processing\" (main processing label)\n- \"Invoice-Vendors\" (supplier invoices)\n- \"Invoice-Clients\" (customer invoices)  \n- \"Invoice-Processed\" (completed items)\n```\n\n**Email Filter Configuration:**\nSet up automatic labeling rules:\n- Emails from known vendors → Auto-apply \"Invoice-Processing\"\n- Emails with \"Invoice\" in subject → Auto-apply \"Invoice-Processing\"  \n- Attachments with PDF extension → Auto-apply \"Invoice-Processing\"\n\n### Configuration Steps\n\n**1. Credential Setup**\n- **Gmail OAuth2**: Full email access including attachments\n- **OpenAI API Key**: GPT-4 access for intelligent data extraction\n- **Google Sheets OAuth2**: Spreadsheet creation and editing permissions\n- **Google Drive OAuth2**: File organization and folder management\n\n**2. Google Drive Folder Structure**\nCreate organized folder hierarchy:\n```\n📁 Invoice Management/\n├── 📁 Incoming Invoices/\n├── 📁 Processed Invoices/\n│   ├── 📁 2024/\n│   │   ├── 📁 Q1/\n│   │   ├── 📁 Q2/\n│   │   └── 📁 Q3/\n├── 📁 Vendor Invoices/\n└── 📁 Client Invoices/\n```\n\n**3. AI Extraction Customization**\nThe default AI prompt extracts standard invoice fields but can be customized for:\n- **Regional Tax Systems**: GST (India), VAT (EU), Sales Tax (US)\n- **Industry-Specific Fields**: Purchase orders, project codes, cost centers\n- **Company Standards**: Custom fields, approval workflows, coding requirements\n- **Multi-Currency**: Exchange rates, currency conversion, international invoices\n\n**4. Data Validation Rules**\nImplement quality control measures:\n- **Required Field Validation**: Ensure critical data is always extracted\n- **Format Standardization**: Consistent date formats, number formatting\n- **Duplicate Detection**: Identify potentially duplicate invoices\n- **Accuracy Scoring**: Confidence levels for extracted data\n\n**5. Workflow Activation**\n- Import the workflow JSON into your n8n instance\n- Configure all credential connections and test each step\n- Process test invoices to verify accuracy\n- Activate Gmail trigger for continuous monitoring\n\n## 🚀 Use Cases\n\n### **Accounting Firms & Bookkeepers**\n- **Client Service Automation**: Process invoices for multiple clients efficiently\n- **Data Entry Elimination**: Convert hours of manual work into automated processing\n- **Accuracy Improvement**: Reduce human errors in financial data transcription\n- **Scalable Operations**: Handle increased client volume without proportional staff increase\n\n### **Small & Medium Businesses**\n- **Accounts Payable Automation**: Streamline vendor invoice processing\n- **Cash Flow Management**: Quick access to payment due dates and amounts\n- **Expense Tracking**: Organized categorization of business expenses\n- **Audit Preparation**: Maintain organized, searchable invoice records\n\n### **Corporate Finance Teams**\n- **Procurement Processing**: Handle purchase orders and vendor invoices at scale\n- **Multi-Location Operations**: Centralize invoice processing across offices\n- **Compliance Management**: Ensure consistent data capture for regulatory requirements\n- **Integration Readiness**: Prepare data for ERP and accounting system import\n\n### **Freelancers & Consultants**\n- **Client Invoice Tracking**: Organize incoming payments and project billing\n- **Expense Management**: Categorize business expenses for tax preparation\n- **Cash Flow Monitoring**: Track outstanding invoices and payment schedules\n- **Professional Organization**: Maintain clean financial records for business growth\n\n### **E-commerce & Retail**\n- **Supplier Invoice Processing**: Manage inventory purchasing and cost tracking\n- **Multi-Vendor Operations**: Handle invoices from numerous suppliers efficiently\n- **Cost Analysis**: Track product costs and supplier performance\n- **Inventory Reconciliation**: Match invoice data with purchase orders and receipts\n\n## 🔧 Advanced Customization Options\n\n### **Multi-Format Invoice Handling**\nExtend processing capabilities:\n```\n- PDF Text-Based: Standard invoice PDFs with selectable text\n- Scanned Documents: Add OCR processing for image-based invoices\n- Email Body Invoices: Extract data from invoice details in email content  \n- Excel Attachments: Process invoices sent as spreadsheet files\n- Multi-Page Documents: Handle complex invoices with multiple pages\n```\n\n### **Intelligent Data Validation**\nImplement quality assurance features:\n- **Cross-Reference Validation**: Compare extracted data against purchase orders\n- **Vendor Database Matching**: Verify company details against known vendor lists\n- **Tax Calculation Verification**: Validate tax amounts and rates for accuracy\n- **Currency Conversion**: Handle multi-currency invoices with real-time exchange rates\n\n### **Workflow Integration Extensions**\nConnect to existing business systems:\n- **ERP Integration**: Direct data export to SAP, Oracle, or Microsoft Dynamics\n- **Accounting Software**: Push data to QuickBooks, Xero, or FreshBooks\n- **Approval Workflows**: Add review and approval steps before final processing\n- **Payment Processing**: Connect to banking systems for automated payment scheduling\n\n### **Advanced Analytics & Reporting**\nGenerate business insights:\n- **Vendor Performance Analysis**: Track pricing trends and payment terms\n- **Expense Category Reporting**: Automated expense categorization and analysis\n- **Cash Flow Forecasting**: Predict payment obligations based on due dates\n- **Audit Trail Management**: Maintain comprehensive processing logs for compliance\n\n## 📊 Extracted Data Structure\n\n### **Standard Invoice Fields (25+ Data Points)**\nThe AI extraction captures comprehensive invoice information:\n\n**Header Information:**\n- Billed To (Customer/Company Name)\n- Invoice Number (Unique Identifier)\n- Date of Issue (Invoice Creation Date)\n- Due Date (Payment Deadline)\n\n**Line Item Details:**\n- Item Description (Product/Service Details)\n- Quantity (Number of Items/Hours)\n- Rate (Unit Price)\n- Amount (Line Total)\n\n**Tax and Financial Calculations:**\n- CGST/SGST Rates and Amounts (Indian GST System)\n- VAT Calculations (European Tax System)\n- Subtotal (Pre-tax Amount)\n- Total Amount (Final Invoice Value)\n\n**Company and Contact Information:**\n- Vendor Company Name\n- Contact Phone/Mobile\n- Email Address\n- Website URL\n- GST Registration Number\n- PAN Number (Indian Tax ID)\n\n**Address Information:**\n- Billing Address\n- Shipping Address  \n- Place of Supply\n- Place of Delivery\n\n**Payment Details:**\n- Transaction IDs\n- Payment Mode (Check, Bank Transfer, Card)\n- Terms and Conditions\n- Special Instructions\n\n### **Sample Extracted Data:**\n```json\n{\n  \"billed_to\": \"Tech Solutions Inc.\",\n  \"invoice_number\": \"INV-2024-0156\",\n  \"date_of_issue\": \"2024-03-15\",\n  \"due_date\": \"2024-04-15\",\n  \"item_0_description\": \"Web Development Services\",\n  \"item_0_quantity\": 40,\n  \"item_0_rate\": 75.00,\n  \"item_0_amount\": 3000.00,\n  \"tax_0_cgst_rate\": 9,\n  \"tax_0_cgst_amount\": 270.00,\n  \"tax_0_sgst_rate\": 9,\n  \"tax_0_sgst_amount\": 270.00,\n  \"subtotal\": 3000.00,\n  \"total\": 3540.00,\n  \"company_name\": \"Digital Services LLC\",\n  \"company_email\": \"billing@digitalservices.com\",\n  \"payment_transaction_ids\": \"TXN123456789\",\n  \"mode_of_payment\": \"Bank Transfer\"\n}\n```\n\n## 🛠️ Troubleshooting & Best Practices\n\n### **Common Issues & Solutions**\n\n**PDF Extraction Challenges**\n- **Scanned Documents**: Original workflow handles text-based PDFs only\n- **Complex Layouts**: Some invoice formats may require prompt refinement\n- **Multi-Page Invoices**: Large invoices might need pagination handling\n- **Password Protection**: Encrypted PDFs require manual processing\n\n**AI Extraction Accuracy**\n- **Field Recognition**: Some custom invoice formats may need prompt tuning\n- **Currency Handling**: Multi-currency invoices may require specific configuration\n- **Date Formats**: International date formats might need standardization\n- **Vendor Variations**: Different vendor invoice styles may affect accuracy\n\n**Gmail Integration Limitations**\n- **Label Management**: Ensure consistent labeling for proper processing\n- **Attachment Size**: Large PDFs may hit Gmail API limits\n- **Email Volume**: High-volume processing may require rate limiting\n- **Security Settings**: Corporate Gmail may have additional restrictions\n\n### **Optimization Strategies**\n\n**Processing Efficiency**\n- **Batch Processing**: Group similar invoices for more efficient processing\n- **Template Recognition**: Create vendor-specific extraction templates\n- **Quality Scoring**: Implement confidence ratings for extracted data\n- **Error Handling**: Add fallback processes for failed extractions\n\n**Data Quality Assurance**\n- **Validation Rules**: Implement business logic for data verification\n- **Duplicate Detection**: Prevent duplicate invoice processing\n- **Manual Review Queues**: Flag uncertain extractions for human review\n- **Audit Logging**: Maintain detailed processing logs for troubleshooting\n\n**Business Process Integration**\n- **Approval Workflows**: Add management approval steps for high-value invoices\n- **Exception Handling**: Create special processes for unusual invoice types\n- **Reporting Automation**: Generate regular summaries of processed invoices\n- **Archive Management**: Implement retention policies for processed documents\n\n## 📈 Success Metrics\n\n### **Efficiency Improvements**\n- **Processing Time**: Reduce manual data entry from hours to minutes\n- **Accuracy Rates**: Achieve 95%+ data extraction accuracy\n- **Volume Capacity**: Process 10-50x more invoices with same resources\n- **Error Reduction**: Eliminate manual transcription errors\n\n### **Business Impact Measurements**\n- **Cost Savings**: Calculate labor cost reduction from automation\n- **Cash Flow Management**: Faster invoice processing enables better payment scheduling\n- **Compliance**: Improved audit trails and data consistency\n- **Scalability**: Ability to handle business growth without proportional staff increase\n\n## 📞 Questions & Support\n\nNeed help implementing or optimizing your AI Invoice Processor Agent?\n\n**📧 Expert Technical Support**\n- **Email**: Yaron@nofluff.online\n- **Response Time**: Within 24 hours on business days\n- **Specialization**: Invoice processing automation, AI data extraction, accounting workflow integration\n\n**🎥 Comprehensive Training Resources**\n- **YouTube Channel**: [https://www.youtube.com/@YaronBeen/videos](https://www.youtube.com/@YaronBeen/videos)\n  - Complete setup and configuration walkthroughs\n  - Advanced customization for different invoice types\n  - Integration tutorials for popular accounting software\n  - Troubleshooting common extraction and processing issues\n  - Best practices for financial document automation\n\n**🤝 Professional Community & Updates**\n- **LinkedIn**: [https://www.linkedin.com/in/yaronbeen/](https://www.linkedin.com/in/yaronbeen/)\n  - Connect for ongoing automation consulting and support\n  - Share your invoice processing success stories and ROI results\n  - Access exclusive workflow templates and advanced configurations\n  - Join discussions about financial automation trends and innovations\n\n**💬 Support Request Guidelines**\nInclude in your support message:\n- Your current invoice processing volume and types\n- Specific vendor formats or invoice layouts you handle\n- Target accounting software or systems for integration\n- Any technical errors or extraction accuracy issues\n- Current manual processing workflow and pain points\n\n\n\n---\n\n*Ready to eliminate manual invoice processing forever? Deploy this AI Invoice Processor Agent and transform your accounting workflow from tedious data entry into intelligent, automated financial management!*",
+			"nodes": [
+				"n8n-nodes-base.gmailTrigger",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:googleSheets"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 86.41,
+			"scoreBreakdown": {
+				"traction": 0.598,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.889
+			},
+			"source": "https://n8n.io/workflows/4376",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 4247,
+			"slug": "invoice-processor-validator-with-ocr-ai-google-sheets-4247",
+			"name": "Invoice Processor & Validator with OCR, AI & Google Sheets",
+			"description": "### 📝 Say goodbye to manual invoice checking! \n**This smart workflow automates** your entire invoice processing pipeline using **AI**, **OCR**, and **Google Sheets**.\n\n---\n\n### ⚙️ **What This Workflow Does:**\n\n📥 **1. Reads an invoice PDF**\n— Select a local PDF invoice from your machine.\n\n🔍 **2. Extracts raw text using OCR**\n— Converts scanned or digital PDFs into readable text.\n\n🧠 **3. AI Agent processes the text**\n— Transforms messy raw text into clean JSON using natural language understanding.\n\n🧱 **4. Structures and refines the JSON**\n— Converts AI output into a structured, usable format.\n\n🔄 **5. Splits item-wise data**\n— Extracts individual invoice line items with all details.\n\n🆔 **6. Generates unique keys**\n— Creates a unique identifier for each item for tracking.\n\n📊 **7. Updates Google Sheet**\n— Adds extracted items to your designated sheet automatically.\n\n📂 **8. Fetches master item data**\n— Loads your internal product master to validate against.\n\n✅ **9. Validates item name & cost**\n— Compares extracted items with your official records to verify accuracy.\n\n📌 **10. Updates results per item**\n— Marks each item as **Valid** or **Invalid** in the sheet based on matching.\n\n---\n\n### 💼 **Use Case:**\n\nPerfect for businesses, freelancers, or operations teams who receive invoices and want to **automate validation**, **detect billing errors**, and **log everything seamlessly in Google Sheets** — all using the power of **AI + n8n**.\n\n&gt; 🔁 Fast. Accurate. Zero manual work.\n\n---\n`#OCR #AI #Invoices #Automation`.\n",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.readWriteFile",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:manual", "ai", "integration:googleSheets"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.33,
+			"scoreBreakdown": {
+				"traction": 0.638,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.714
+			},
+			"source": "https://n8n.io/workflows/4247",
+			"author": "itechdp",
+			"success": true
+		},
+		{
+			"id": 6067,
+			"slug": "auto-generate-seo-blog-posts-with-perplexity-gpt-leonardo-wo-6067",
+			"name": "Auto-Generate SEO Blog Posts with Perplexity, GPT, Leonardo & WordPress",
+			"description": "## ✨ SEO Blog Post Automation with Perplexity, GPT, Leonardo AI & WordPress\n\nThis workflow automates the creation and publishing of weekly SEO-optimized blog posts using AI and publishes them directly to WordPress — with featured images and tracking in Google Sheets.\n\n---\n\n## 🧠 Who is this for\n\nThis automation is ideal for:\n\n- Startup platforms and tech blogs  \n- Content creators and marketers  \n- Solopreneurs who want consistent blog output  \n- Spanish-speaking audiences focused on startup trends  \n\n---\n\n## ⚙️ What it does\n\n- ⏰ Runs every Monday at 6:00 AM via CRON  \n- 📡 Uses Perplexity AI to research trending startup topics  \n- 📝 Generates a 1000–1500 word article with GPT in structured HTML  \n- 🎨 Creates a cinematic blog image using Leonardo AI  \n- 🖼️ Uploads the image to WordPress with alt text and SEO-friendly filename  \n- 📰 Publishes the post in a pre-defined category  \n- 📊 Logs the post in Google Sheets for tracking  \n\n---\n\n## 🚀 How to set it up\n\n1. **Connect your credentials**:\n   - Perplexity API  \n   - OpenAI (GPT-4.1 Mini or similar)  \n   - Leonardo AI (Bearer token)  \n   - WordPress (Basic Auth)  \n   - Google Sheets (OAuth2)\n\n2. **Customize your content**:\n   - Adjust the prompt inside the HTTP node to fit your tone or focus  \n   - Change the WordPress category ID  \n   - Update scheduling if you want a different publishing day  \n\n3. **Test the workflow manually** to ensure all steps function correctly\n\n---\n\n## 💡 Pro tips\n\n- Add Slack or email nodes to get notified when a post goes live  \n- Use multiple categories or RSS feeds for content diversification  \n- Adjust GPT prompt to support different languages or tones  \n- Add post-validation rules if needed before publishing  \n\n---\n\n## 🎯 Why this matters\n\nThis workflow gives you a full editorial process on autopilot: research, writing, design, publishing, and tracking — all powered by AI. No more blank pages or manual posting.\n\n**Use it to scale your content strategy, boost your SEO, and stay relevant — 100% hands-free.**\n",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:httpRequest"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 86.33,
+			"scoreBreakdown": {
+				"traction": 0.682,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.538
+			},
+			"source": "https://n8n.io/workflows/6067",
+			"author": "cristiantala",
+			"success": true
+		},
+		{
+			"id": 7163,
+			"slug": "automate-hyper-personalized-email-outreach-with-ai-gmail-goo-7163",
+			"name": "Automate hyper-personalized email outreach with AI, Gmail & Google Sheets",
+			"description": "# This n8n template from [Intuz](https://www.intuz.com/) provides a complete and automated solution for hyper-personalized email outreach. \n\nIt powerfully combines AI with Gmail and Google Sheets, using specific keywords and prospect data to automatically craft unique, compelling email content that boosts engagement and secures more replies. \n\nInstead of manually replying to every lead or inquiry, this template does the heavy lifting for you, ensuring every response is relevant, thoughtful, and timely.\n\nIt reads each person's unique inquiry, uses OpenAI to craft a perfectly tailored and human-like response, and sends it directly from your Gmail account. Ideal for sales, marketing, and customer support teams looking to boost engagement and save hours of manual work.\n\n## Use Cases:\n- Sales Teams: Instantly follow up with new leads from your website's contact form with a personalized touch.\n\n- Customer Support: Provide initial, intelligent responses to support tickets, answering common questions or acknowledging receipt of a complex issue.\n\n- Marketing Automation: Nurture leads by responding to content downloads or webinar sign-ups with relevant, non-generic information.\n\n- Founders & Solopreneurs: Manage all incoming business inquiries (partnerships, media, etc.) efficiently without sacrificing quality.\n\n\n## How It Works:\n1. Trigger the Flow (Manual): Start the automation whenever you're ready to process a new batch of inquiries from your sheet.\n\n2. Fetch Inquiries from Google Sheets: The workflow connects to your specified Google Sheet and reads each row. It pulls the contact's First Name, Email ID, the Inquiry Intent (e.g., \"Demo Request,\" \"Pricing Inquiry\"), and the full text of their Original Inquiry.\n\n3. Sync Your Signature: Before writing the email, an HTTP Request node dynamically fetches your display name from your Gmail account settings. This ensures the signature in the generated email (Thanks, {{Your Name}}) is always accurate.\n\n4. Craft a Hyper-Personalized Reply with AI: It uses this context to generate a high-quality, professional, and friendly email reply in HTML format. For example:\n- If the intent is \"Technical Support,\" the AI will generate a helpful, empathetic response addressing the technical issue.\n- If the intent is \"Partnership Proposal,\" it will draft a professional reply acknowledging the proposal and outlining the next steps.\n\n5. Send via Gmail: The final node takes the AI-generated message, adds a relevant subject line (e.g., \"Re: Your Demo Request\"), and sends it directly to the contact's email address from your connected Gmail account.\n\nThis process loops for every single row in your Google Sheet, turning a list of names into a series of meaningful conversations.\n\n## Setup Instructions:\nTo get this workflow running, you'll need to configure a few things:\n\n1. Credentials:\nGoogle: Connect your Google account via OAuth2 and ensure you have enabled access for Google Sheets, Google Drive, and Gmail.\n2. OpenAI: Add your OpenAI API key as a credential.\n3. Google Sheet Setup:\nCreate a Google Sheet with the following exact column headers:\n-First Name\n-Email ID\n-Inquiry Intent (A short category like \"Demo Request\", \"Billing Issue\", etc.)\n-Original Inquiry (The full text of the email or message you received).\n4. Node Configuration:\nGet row(s) in sheet: Select your Google Sheet document and the specific sheet name.\nMessage a model (OpenAI): Choose your preferred OpenAI model (e.g., gpt-4-turbo, gpt-3.5-turbo).\n5. HTTP Request & Send Personalized emails: These nodes should automatically use your configured Gmail credentials. No changes are typically needed.\n\n\n## Connect with us\n\n- Website: https://www.intuz.com/n8n-workflow-automation-templates\n- Email: getstarted@intuz.com\n- LinkedIn: https://www.linkedin.com/company/intuz\n- Get Started: https://n8n.partnerlinks.io/intuz\n\n\n## For Custom Worflow Automation \n\n\nClick here- [Get Started](https://www.intuz.com/get-started)",
+			"nodes": [
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:manual", "ai", "integration:googleSheets"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 86.3,
+			"scoreBreakdown": {
+				"traction": 0.565,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/7163",
+			"author": "intuz",
+			"success": true
+		},
+		{
+			"id": 3435,
+			"slug": "get-qualified-leads-in-one-click-from-apollo-to-airtable-3435",
+			"name": "Get Qualified Leads in One Click from Apollo to Airtable",
+			"description": "## You Don’t Need More Tools. You Just Need the Right Leads.\nWhy spend $1,000s on lead gen when your perfect leads are already waiting in Apollo? You’ve already filtered the ideal prospects. You know who they are, where they work, and what they do.\n\nNow **imagine turning that list into enriched, ready-to-contact leads—without paying pricey Apollo's recurring subscription** *(spoiler: you will pay only 0.60$ per 500 leads)*.\n\n## From Filter to Outreach-Ready in Seconds\nWith the Lead Generation System, you just drop your Apollo search URL.\n\n**The workflow does the rest:**\n✅ Scrapes all matching contacts from your Apollo filter\n✅ Enriches and organizes the data (names, roles, emails, LinkedIns, companies, etc.)\n✅ Delivers the final lead list to Airtable—or your CRM of choice\n\nNo more manual exports. \nNo CSV mess. \nNo VA needed.\nJust qualified leads, cleaned and ready to go.\n\n## Perfect For\n- Founders doing DIY outbound\n- Growth marketers scaling cold email\n- Agencies running lead-gen for clients\n- Anyone tired of paying too much for messy, outdated lists\n\n\n## Setup Guide\nI built a step-by-step guide to setup this workflow in 5 to 10 minutes, available here: [https://notanothermarketer.gitbook.io/home/templates/lead-generation](https://notanothermarketer.gitbook.io/home/templates/lead-generation)\n\nThis template is free. Enjoy!\n",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.airtable",
+				"n8n-nodes-base.if"
+			],
+			"tags": ["trigger:manual", "integration:set"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 86.15,
+			"scoreBreakdown": {
+				"traction": 0.558,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/3435",
+			"author": "notanothermarketer",
+			"success": true
+		},
+		{
+			"id": 4359,
+			"slug": "ai-powered-post-sales-call-automated-proposal-generator-4359",
+			"name": "AI-Powered Post-Sales Call Automated Proposal Generator",
+			"description": "# AI-Powered Proposal Generator - Sales Automation Workflow\n\n## Overview\n![Screenshot 20250524 143046.png](fileId:1373)\nThis n8n workflow automates the entire proposal generation process using AI, transforming client requirements into professional, customized proposals delivered via email in seconds.\n\n## Use Case\nPerfect for agencies, consultants, and sales teams who need to generate high-quality proposals quickly. Instead of spending hours writing proposals manually, this workflow captures client information through a web form and uses GPT-4 to generate contextually relevant, professional proposals.\n\n## How It Works\n1. **Form Trigger** - Captures client information through a customizable web form\n2. **OpenAI Integration** - Processes form data and generates structured proposal content\n3. **Google Drive** - Creates a copy of your proposal template\n4. **Google Slides** - Populates the template with AI-generated content\n5. **Gmail** - Automatically sends the completed proposal to the client\n\n## Key Features\n- **AI Content Generation**: Uses GPT-4 to create personalized proposal content\n- **Professional Templates**: Integrates with Google Slides for polished presentations\n- **Automated Delivery**: Sends proposals directly to clients via email\n- **Form Integration**: Captures all necessary client data through web forms\n- **Customizable Output**: Generates structured proposals with multiple sections\n\n## Template Sections Generated\n- Proposal title and description\n- Problem summary analysis\n- Three-part solution breakdown\n- Project scope details\n- Milestone timeline with dates\n- Cost integration\n\n## Requirements\n- **n8n instance** (cloud or self-hosted)\n- **OpenAI API key** for content generation\n- **Google Workspace account** for Slides and Gmail\n- **Basic n8n knowledge** for setup and customization\n\n## Setup Complexity\n**Intermediate** - Requires API credentials setup and basic workflow customization\n\n## Benefits\n- **Time Savings**: Reduces proposal creation from hours to minutes\n- **Consistency**: Ensures all proposals follow the same professional structure\n- **Personalization**: AI analyzes client needs for relevant content\n- **Automation**: Eliminates manual copy-paste and formatting work\n- **Scalability**: Handle multiple proposal requests simultaneously\n\n## Customization Options\n- Modify AI prompts for different industries or services\n- Customize Google Slides template design\n- Adjust form fields for specific information needs\n- Personalize email templates and signatures\n- Configure milestone templates for different project types\n\n## Error Handling\nIncludes basic error handling for API failures and form validation to ensure reliable operation.\n\n## Security Notes\nAll credentials have been removed from this template. Users must configure their own:\n- OpenAI API credentials\n- Google OAuth2 connections for Slides, Drive, and Gmail\n- Form webhook configuration\n\nThis workflow demonstrates practical AI integration in business processes and showcases n8n's capabilities for complex automation scenarios.",
+			"nodes": [
+				"n8n-nodes-base.googleSlides",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:googleSlides"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 86.1,
+			"scoreBreakdown": {
+				"traction": 0.555,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4359",
+			"author": "dominixai",
+			"success": true
+		},
+		{
+			"id": 14216,
+			"slug": "generate-concert-ticket-pdfs-with-qr-codes-using-pdf-generat-14216",
+			"name": "Generate concert ticket PDFs with QR codes using PDF Generator API",
+			"description": "Generate personalized concert ticket PDFs with QR codes using PDF Generator API, then email them to attendees, log sales to Google Sheets, and notify organizers via Slack — all triggered from a simple web form.\n\n## Who is this for\n\nEvent organizers, ticketing teams, and developers who need an automated pipeline to issue branded PDF concert tickets with unique QR codes for venue entry — without building a custom backend.\n\n## How it works\n\n1. An attendee fills out a **web form** with their name, email, event details, seat number, and ticket tier (General / VIP / Backstage).\n2. The workflow generates a unique ticket ID and prepares all data for the PDF template.\n3. **PDF Generator API** renders a personalized PDF ticket. The QR code is a native template component that encodes the ticket ID automatically.\n4. A styled **HTML confirmation email** with a download link is sent to the attendee via Gmail.\n5. The ticket details are logged to a **Google Sheets** spreadsheet for tracking and attendance management.\n6. A **Slack notification** alerts the event organizer with a summary of the newly issued ticket.\n\n## Set up\n\n1. **PDF Generator API** — Sign up at [pdfgeneratorapi.com](https://pdfgeneratorapi.com), create a ticket template with a QR Code component bound to `{{ ticket_id }}`, and note your template ID.\n2. **Template ID** — Open the \"Prepare Ticket Data\" Code node and replace the `TEMPLATE_ID` value with your own.\n3. **Credentials** — Connect your accounts in each node: PDF Generator API, Gmail, Google Sheets, and Slack.\n4. **Google Sheets** — Create a spreadsheet with columns: `Ticket ID`, `Attendee`, `Email`, `Event`, `Venue`, `Date`, `Seat`, `Tier`, `PDF URL`, `Issued At`. Set the spreadsheet ID in the \"Log Ticket Sale\" node.\n5. **Slack** — Choose a channel (e.g. `#tickets`) in the \"Notify Event Organizer\" node.\n\n## Requirements\n\n- [PDF Generator API](https://pdfgeneratorapi.com) account (free trial available)\n- Gmail account (OAuth)\n- Google Sheets account (OAuth)\n- Slack workspace (optional — remove the last node if not needed)\n\n## How to customize\n\n- **Output format** — The PDF node returns a hosted URL by default (valid 30 days). Switch to `File` output to attach the PDF directly to the email instead.\n- **Ticket tiers** — Add or rename tiers in the form node and update the tier mapping logic in the \"Prepare Ticket Data\" Code node.\n- **Email design** — Edit the \"Build Confirmation Email\" Code node to match your brand colors and layout.\n- **Remove Slack** — Simply delete the \"Notify Event Organizer\" node if you don't need organizer alerts.\n- **Add payment** — Insert a Stripe or payment node before the form confirmation to handle paid tickets.",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.code",
+				"@pdfgeneratorapi/n8n-nodes-pdf-generator-api.pdfGeneratorApi",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.slack"
+			],
+			"tags": ["trigger:formTrigger", "integration:code"],
+			"triggerType": "formTrigger",
+			"hasAI": false,
+			"score": 86.1,
+			"scoreBreakdown": {
+				"traction": 0.591,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.857
+			},
+			"source": "https://n8n.io/workflows/14216",
+			"author": "marian",
+			"success": true
+		},
+		{
+			"id": 3705,
+			"slug": "generate-custom-ai-images-with-openai-gpt-image-1-model-3705",
+			"name": "Generate Custom AI Images with OpenAI GPT-Image-1 Model",
+			"description": "**How it works**  \n1. Trigger the workflow manually via the n8n UI.  \n2. Define key parameters like the image prompt, number of images, size, quality, and model.  \n3. Send a POST request to OpenAI’s image generation API using those inputs.  \n4. Split the API response to handle multiple images.  \n5. Convert the base64 image data into downloadable binary files.\n\n**Set up steps**  \nInitial setup takes around 5–10 minutes. You’ll need an OpenAI API key, a configured HTTP Request node with credentials, and to customize the prompt/parameter fields in the “Set Variables” node. No advanced config or external services needed.\n\n**Important Note**\nYou have to make sure to complete OpenAI's new verification requirements to use their new image API:\nhttps://help.openai.com/en/articles/10910291-api-organization-verification\n\nIt only takes a few minutes and does not cost any money.",
+			"nodes": [
+				"n8n-nodes-base.convertToFile",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:manual", "integration:convertToFile"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 86.08,
+			"scoreBreakdown": {
+				"traction": 0.554,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/3705",
+			"author": "aiwithapex",
+			"success": true
+		},
+		{
+			"id": 3942,
+			"slug": "ai-powered-restaurant-order-chatbot-with-gpt-4o-for-pos-inte-3942",
+			"name": "AI-Powered Restaurant Order Chatbot with GPT-4o for POS Integration",
+			"description": "This workflow automates the restaurant POS (Point of Sale) data management process, facilitating seamless order handling, customer tracking, inventory management, and sales reporting. It retrieves order details, processes payment information, updates inventory, and generates real-time sales reports, all integrated into a centralized system that improves restaurant operations.\n\nThe workflow integrates various systems, including a POS terminal to gather order data, payment gateways to process transactions, inventory management tools to update stock, and reporting tools like Google Sheets or an internal database for generating sales and performance reports.\n\nWho Needs Restaurant POS Automation?\nThis POS automation workflow is ideal for restaurant owners, managers, and staff looking to streamline their operations:\n\nRestaurant Owners – Automate order processing, track sales, and monitor inventory to ensure smooth operations.\n\nManagers – Access real-time sales data and performance reports to make informed decisions.\n\nStaff – Reduce manual work, focusing on providing better customer service while the system handles orders and payments.\n\nInventory Teams – Automatically update inventory levels based on orders and ingredient usage.\n\nIf you need a reliable and automated POS solution to manage restaurant orders, payments, inventory, and reporting, this workflow minimizes human error, boosts efficiency, and saves valuable time.\n\nWhy Use This Workflow?\n\nEnd-to-End Automation – Automates everything from order input to inventory updates and sales reporting.\n\nSeamless Integration – Connects POS, payment systems, inventory management, and reporting tools for smooth data flow.(if needed)\n\nReal-Time Data – Provides up-to-the-minute reports on sales, stock levels, and order statuses.\n\nScalable & Efficient – Supports multiple locations, multiple users, and high order volumes.\n\nStep-by-Step: How This Workflow Manages POS Data\n\nCollect Orders – Retrieves order details from the POS system, including customer information, ordered items, and payment details.\n\nUpdate Inventory – Decreases inventory levels based on sold items, ensuring stock counts are always accurate.\n\nGenerate Reports – Compiles sales, revenue, and inventory data into real-time reports and stores them in Google Sheets or an internal database.\n\nTrack Customer Data – Keeps a log of customer details and order history for better service and marketing insights.\n\nCustomization: Tailor to Your Needs\n\nMultiple POS Systems – Adapt the workflow to work with different POS systems or terminals based on your restaurant setup.\n\nCustom Reporting – Modify the reporting format or include specific sales metrics (e.g., daily totals, best-selling items, employee performance).\n\nInventory Management – Adjust inventory updates to include alerts when stock reaches critical levels or needs reordering.\n\nIntegration with Accounting Software – Connect with platforms like QuickBooks for automated financial tracking.\n\n🔑 Prerequisites\n\nPOS System Integration – Ensure the POS system can export order data in a compatible format.\n\nPayment Gateway API – Set up the necessary API keys for payment processing (e.g., Stripe, PayPal).\n\nInventory Management Tools – Use inventory software or databases that can automatically update stock levels.\n\nReporting Tools – Use Google Sheets or an internal database to store and generate sales and inventory reports.\n\n🚀 Installation & Setup\n\nConfigure Credentials\n\nSet up API credentials for payment gateways and inventory management tools.\n\nImport Workflow\n\nImport the workflow into your automation platform (e.g., n8n, Zapier).\n\nLink POS system, payment gateway, and inventory management systems.\n\nTest & Run\n\nProcess a test order to ensure that data flows correctly through each step.\n\nVerify that inventory updates and reports are generated as expected.\n\n⚠ Important\n\nData Privacy – Ensure compliance with data protection regulations (e.g., GDPR, PCI DSS) when handling customer payment and order data.\n\nSystem Downtime – Monitor system performance to ensure that the workflow runs without disruptions during peak hours.\n\nSummary\nThis restaurant POS automation workflow integrates order management, payment processing, inventory updates, and real-time reporting, enabling efficient restaurant operations. Whether you are running a single location or a chain of restaurants, this solution streamlines daily tasks, reduces errors, and provides valuable insights, saving time and improving customer satisfaction. 🚀",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.informationExtractor",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.noOp",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.toolWorkflow",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow"
+			],
+			"tags": ["trigger:other", "ai", "integration:langchain"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 86.07,
+			"scoreBreakdown": {
+				"traction": 0.589,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.857
+			},
+			"source": "https://n8n.io/workflows/3942",
+			"author": "shivam840708",
+			"success": true
+		},
+		{
+			"id": 3912,
+			"slug": "automate-lead-qualification-with-retellai-phone-agent-openai-3912",
+			"name": "Automate Lead Qualification with RetellAI Phone Agent, OpenAI GPT & Google Sheet",
+			"description": "![Workflow Screenshot](https://www.dr-firas.com/Build-a-Phone-Agent.png)\n\n## 👉 Build a Phone Agent to qualify outbound leads and schedule inbound calls\n\n\n### Who is this for?\n\nThis workflow is designed for **sales teams**, **call centers**, and **businesses handling both outbound and inbound lead calls** who want to automate their qualification, follow-up, and call documentation process without manual intervention. It’s ideal for teams using **Google Sheets, RetellAI, OpenAI, and Gmail** as part of their tech stack.\n\n---\n\n### Real-World Use Cases\n\n- 🛍 E-commerce – Instantly handle product FAQs and order status checks, 24/7.\n- 🏬 Retail Stores – Share store hours, directions, and return policies without lifting a finger.\n- 🍽 Restaurants – Take reservations or answer menu questions automatically.\n- 💼 Service Providers – Book appointments or consultations while you focus on your craft.\n- 📞 Any Local Business – Deliver friendly, consistent phone support — no live agent required.\n\n---\n\n### What problem is this workflow solving?\n\nManaging lead calls at scale can be chaotic—between scheduling outbound qualification calls, handling inbound appointment requests, and making sure every call is documented and followed up. This workflow automates the entire process, reducing human error and saving time by:\n\n- ✅ Sending reminders to reps for outbound calls\n- ✅ Automatically placing calls with RetellAI\n- ✅ Handling inbound calls and checking caller details\n- ✅ Generating and emailing call summaries automatically\n\n---\n\n### What this workflow does\n\nThis n8n template connects Google Sheets, RetellAI, OpenAI, and Gmail into a seamless workflow:\n\n1. **Outbound Lead Qualification Workflow**\n   - Triggers when a new lead is added to Google Sheets\n   - Sends an SMS notification to remind the rep to call in 5 minutes\n   - (Optional) Waits 5 minutes\n   - Initiates an automated call to the lead via RetellAI\n\n2. **Inbound Call Appointment Scheduler**\n   - Receives inbound calls from RetellAI (via webhook)\n   - Checks if the caller’s number exists in Google Sheets\n   - Responds to RetellAI with a success or error message\n\n3. **Post-Call Workflow**\n   - Receives post-call data from RetellAI\n   - Filters only analyzed calls\n   - Updates the lead’s record in Google Sheets\n   - Uses OpenAI to generate a call summary\n   - Emails the summary to a team inbox or rep\n\n---\n\n### Setup\n\n✅ You need an active **RetellAI API key**\n\n1. Sign up for RetellAI, create an agent, and set the webhook URLs (n8n_call for call events).\n2. Purchase a Twilio phone number and link it to the agent.  \n\n✅ Your **Google Sheet must have a column for phone numbers** (e.g., \"Phone\")  \n✅ **Gmail account** connected and authorized in n8n  \n✅ **OpenAI API key** added to your environment variables or credentials\n\n1. Configure your Google Sheets node with the correct spreadsheet ID and range\n2. Add your RetellAI API key to the HTTP request nodes\n3. Connect your Gmail account in the Gmail node\n4. Add your OpenAI key in the OpenAI node\n\n👉 See full setup guide here: [Notion Documentation](https://automatisation.notion.site/Build-a-Phone-Agent-to-qualify-outbound-leads-and-schedule-inbound-calls-1eb3d6550fd9807993dce3c6ed111554)\n\n---\n\n### How to customize this workflow to your needs\n\n- **Change SMS content**: Edit the text in the “Send SMS reminder” node to match your team’s tone\n- **Modify call wait time**: Enable and adjust the “Wait 5 minutes” node to any delay you prefer\n- **Add CRM integration**: Replace or extend the Google Sheets node to update your CRM instead of a spreadsheet\n- **Customize call summary prompts**: Edit the prompt sent to OpenAI to change the summary style or add extra insights\n- **Send email to different recipients**: Change the recipient address in the Gmail node or make it dynamic from the lead record\n\n\n---\n\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/)",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleSheetsTrigger",
+				"n8n-nodes-base.twilio",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.respondToWebhook",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.gmail",
+				"@n8n/n8n-nodes-langchain.openAi"
+			],
+			"tags": ["trigger:other", "ai", "integration:googleSheets"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 86,
+			"scoreBreakdown": {
+				"traction": 0.603,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.786
+			},
+			"source": "https://n8n.io/workflows/3912",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 3900,
+			"slug": "automated-youtube-video-scheduling-ai-metadata-generation-3900",
+			"name": "Automated YouTube Video Scheduling & AI Metadata Generation 🎬",
+			"description": "\n\n## 👥 Who Is This For?\nContent creators, marketing teams, and channel managers who need to streamline video publishing with optimized metadata and scheduled releases across multiple videos.\n\n## 🛠 What Problem Does This Solve?\nManual YouTube video publishing is time-consuming and often results in inconsistent descriptions, tags, and scheduling. This workflow fully automates:\n* Extracting video transcripts via Apify for metadata generation\n* Creating SEO-optimized descriptions and tags for each video\n* Setting videos to private during initial upload (critical for scheduling)\n* Implementing scheduled publishing at strategic times\n* Maintaining consistent branding and formatting across all content\n\n## 🔄 Node-by-Node Breakdown\n| Step | Node Purpose |\n|------|--------------|\n| 1 | Every Day (Scheduler) | Trigger workflow on a regular schedule |\n| 2 | Get Videos to Harmonize | Retrieve videos requiring metadata enhancement |\n| 3 | Get Video IDs (Unpublished) | Filter for videos that need publishing |\n| 4 | Loop over Video IDs | Process each video individually |\n| 5 | Get Video Data | Retrieve metadata for the current video |\n| 6 | Loop over Videos with Parameter IS | Set parameters for processing |\n| 7 | Set Videos to Private | Ensure videos are private (required for scheduling) |\n| 8 | Apify: Get Transcript | Extract video transcript via Apify |\n| 9 | Fetch Latest Videos | Get most recent channel content |\n| 10 | Loop Over Items | Process each video item |\n| 11 | Generate Description, Tags, etc. | Create optimized metadata from transcript |\n| 12 | AP Clean ID | Format identifiers |\n| 13 | Retrieve Generated Data | Collect the enhanced metadata |\n| 14 | Adjust Transcript Format | Format transcript for better processing |\n| 15 | Update Video's Metadata | Apply generated description and tags to video |\n\n## ⚙️ Pre-conditions / Requirements\n* n8n with YouTube API credentials configured\n* Apify account with API access for transcript extraction\n* YouTube channel with upload permissions\n* Master templates for description formatting\n* Videos must be initially set to private for scheduling to work\n\n## ⚙️ Setup Instructions\n1. Import this workflow into your n8n instance.\n2. Configure YouTube API credentials with proper channel access.\n3. Set up Apify integration with appropriate actor for transcript extraction.\n4. Define scheduling parameters in the Every Day node.\n5. Configure description templates with placeholders for dynamic content.\n6. Set default tags and customize tag generation rules.\n7. Test with a single video before batch processing.\n\n## 🎨 How to Customize\n* Adjust prompt templates for description generation to match your brand voice.\n* Modify tag selection algorithms based on your channel's SEO strategy.\n* Create multiple publishing schedules for different content categories.\n* Integrate with analytics tools to optimize publishing times.\n* Add notification nodes to alert when videos are successfully scheduled.\n\n## ⚠️ Important Notes\n* Videos MUST be uploaded as private initially - the Publish At logic only works for private videos that haven't been published before.\n* Publishing schedules require videos to remain private until their scheduled time.\n* Transcript quality affects metadata generation results.\n* Consider YouTube API quotas when scheduling large batches of videos.\n\n## 🔐 Security and Privacy\n* API credentials are stored securely within n8n.\n* Transcripts are processed temporarily and not stored permanently.\n* Webhook URLs should be protected to prevent unauthorized triggering.\n* Access to the workflow should be limited to authorized team members only.",
+			"nodes": [
+				"n8n-nodes-base.youTube",
+				"n8n-nodes-base.splitInBatches",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.removeDuplicates",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:manual", "ai", "integration:youTube"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 85.9,
+			"scoreBreakdown": {
+				"traction": 0.665,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.52
+			},
+			"source": "https://n8n.io/workflows/3900",
+			"author": "stardawnai",
+			"success": true
+		},
+		{
+			"id": 3580,
+			"slug": "scrape-linkedin-job-listings-for-hiring-signals-prospecting--3580",
+			"name": "Scrape LinkedIn Job Listings for Hiring Signals & Prospecting with Bright Data",
+			"description": "LinkedIn Hiring Signal Scraper — Jobs & Prospecting Using Bright Data\n\n## Purpose:\nDiscover recent job posts from LinkedIn using Bright Data's Dataset API, clean the results, and log them into Google Sheets — for both job hunting **and** identifying high-intent B2B leads based on hiring activity.\n\n## Use Cases:\n- **Job Seekers** – Spot relevant openings filtered by role, city, and country.  \n- **Sales & Prospecting** – Use job posts as buying signals.  \n  If a company is hiring for a role you support (e.g. marketers, developers, ops) —  \n  it's the perfect time to reach out and offer your services.\n\n## Tools Needed:\n- **n8n Nodes:**\n  - Form Trigger  \n  - HTTP Request  \n  - Wait  \n  - If  \n  - Code  \n  - Google Sheets  \n  - Sticky Notes (for embedded guidance)\n- **External Services:**\n  - [Bright Data](https://brightdata.com) (Dataset API)  \n  - [Google Sheets](https://docs.google.com/spreadsheets/d/1_jbr5zBllTy_pGbogfGSvyv1_0a77I8tU-Ai7BjTAw4/edit?usp=sharing)\n\n## API Keys & Authentication Required:\n- **Bright Data API Key**  \n  → Add in the HTTP Request headers:  \n  `Authorization: Bearer YOUR_BRIGHTDATA_API_KEY`\n\n- **Google Sheets OAuth2**  \n  → Connect your account in n8n to allow read/write access to the spreadsheet.\n\n## General Guidelines:\n- Use descriptive names for all nodes.  \n- Include retry logic in polling to avoid infinite loops.  \n- Flatten nested fields (like `job_poster` and `base_salary`).  \n- Strip out HTML tags from job descriptions for clean output.\n\n## Things to be Aware Of:\n- Bright Data snapshots take ~1–3 minutes — use a Wait node and polling.  \n- Form filters affect output significantly:  \n  🔍 We recommend filtering by **\"Last 7 days\"** or **\"Past 24 hours\"** for fresher data.  \n- Avoid hardcoding values in the form — leave optional filters empty if unsure.\n\n## Post-Processing & Outreach:\n- After data lands in Google Sheets, you can use it to:  \n  - Personalize cold emails based on job titles, locations, and hiring signals.  \n  - Send thoughtful LinkedIn messages (e.g., \"Saw you're hiring a CMO...\")  \n  - Prioritize outreach to companies actively growing in your niche.\n\n## Additional Notes:\n- 📄 Copy the Google Sheet Template:  \n  [Click here to make your copy](https://docs.google.com/spreadsheets/d/1_jbr5zBllTy_pGbogfGSvyv1_0a77I8tU-Ai7BjTAw4/edit?usp=sharing)  \n  → Rename for each campaign or client.\n\n- Form fields include:  \n  - Job Location (city or region)  \n  - Keyword (e.g., CMO, Backend Developer)  \n  - Country (2-letter code, e.g., US, UK)\n\n---\n\nThis workflow gives you a competitive edge —  \n📌 For candidates: Be first to apply.  \n📌 For sellers: Be first to pitch.  \nAll based on live hiring signals from LinkedIn.\n\n---\n\n## STEP-BY-STEP WALKTHROUGH\n\n### Step 1: Set up your Google Sheet\n1. Open this [template](https://docs.google.com/spreadsheets/d/1_jbr5zBllTy_pGbogfGSvyv1_0a77I8tU-Ai7BjTAw4/edit?usp=sharing)\n2. Go to `File → Make a copy`\n3. You'll use this copy as the destination for the scraped job posts\n\n### Step 2: Fill out the Input Form in n8n\nThe form allows you to define what kind of job posts you want to scrape.\n\n**Fields:**\n- **Job Location** → e.g. `New York`, `Berlin`, `Remote`  \n- **Keyword** → e.g. `CMO`, `AI Architect`, `Ecommerce Manager`  \n- **Country Code (2-letter)** → e.g. `US`, `UK`, `IL`\n\n**💡 Pro Tip:**  \nFor best results, set the filter inside the workflow to:  \n`time_range = \"Past 24 hours\"` or `\"Last 7 days\"`  \nThis keeps results relevant and fresh.\n\n### Step 3: Trigger Bright Data Snapshot\nThe workflow sends a request to Bright Data with your input.\n\nExample API Call Body:\n```json\n[\n  {\n    \"location\": \"New York\",\n    \"keyword\": \"Marketing Manager\",\n    \"country\": \"US\",\n    \"time_range\": \"Past 24 hours\",\n    \"job_type\": \"Part-time\",\n    \"experience_level\": \"\",\n    \"remote\": \"\",\n    \"company\": \"\"\n  }\n]\n```\n\nBright Data will start preparing the dataset in the background.\n\n### Step 4: Wait for the Snapshot to Complete\nThe workflow includes a Wait Node and Polling Loop that checks every few minutes until the data is ready.\n\nYou don't need to do anything here — it's all automated.\n\n### Step 5: Clean Up the Results\nOnce Bright Data responds with the full job post list:\n\n✔️ Nested fields like job_poster and base_salary are flattened  \n✔️ HTML in job descriptions is removed  \n✔️ Final data is formatted for export\n\n### Step 6: Export to Google Sheets\nThe final cleaned list is added to your Google Sheet (first tab).\n\nEach row = one job post, with columns like:\n\njob_title, company_name, location, salary_min, apply_link, job_description_plain\n\n### Step 7: Use the Data for Outreach or Research\n#### Example for Job Seekers:\nYou search for:\n\n- Location: Berlin\n- Keyword: Product Designer\n- Country: DE\n- Time range: Past 7 days\n\nNow you've got a live list of roles — with salary, recruiter info, and apply links.\n→ Use it to apply faster than others.\n\n#### Example for Prospecting (Sales / SDR):\nYou search for:\n\n- Location: London\n- Keyword: Growth Marketing\n- Country: UK\n\nAnd find companies hiring growth marketers.\n→ That's your signal to offer help with media buying, SEO, CRO, or your relevant service.\n\nUse the data to:\n- Write personalized cold emails (\"Saw you're hiring a Growth Marketer…\")\n- Start warm LinkedIn outreach\n- Build lead lists of companies actively expanding in your niche\n\n## API Credentials Required:\n- **Bright Data API Key**  \n  Used in HTTP headers: `Authorization: Bearer YOUR_BRIGHTDATA_API_KEY`\n\n- **Google Sheets OAuth2**  \n  Allows n8n to read/write to your spreadsheet\n\n## Adjustments & Customization Tips:\n- Modify the HTTP Request body to add more filters (e.g. job_type, remote, company)\n- Increase or reduce polling wait time depending on Bright Data speed\n- Add scoring logic to prioritize listings based on title or location\n\n## Final Notes:\n- 📄 Google Sheet Template:  \n  [Make your copy here](https://docs.google.com/spreadsheets/d/1_jbr5zBllTy_pGbogfGSvyv1_0a77I8tU-Ai7BjTAw4/edit?usp=sharing)\n\n- ⚙️ Bright Data Dataset API:  \n  Visit [BrightData.com](https://get.brightdata.com/1tndi4600b25)\n\n- 📬 Personalization works best when you act quickly.  \n  Use the freshest data to reach out with context — not generic pitches.\n\n---\n\nThis workflow turns LinkedIn job posts into sales insights and job leads.\nAll in one click. Fully automated. Ready for your next move.",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.set"
+			],
+			"tags": ["trigger:formTrigger", "integration:httpRequest"],
+			"triggerType": "formTrigger",
+			"hasAI": false,
+			"score": 85.88,
+			"scoreBreakdown": {
+				"traction": 0.599,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.778
+			},
+			"source": "https://n8n.io/workflows/3580",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 4057,
+			"slug": "auto-respond-to-gmail-enquiries-using-gpt-4o-dumpling-ai-lan-4057",
+			"name": "Auto-Respond to Gmail Enquiries using GPT-4o, Dumpling AI & LangChain Agent",
+			"description": "\n\n### Who is this for?\n\nThis workflow is perfect for customer support teams, sales departments, or solopreneurs who receive frequent email enquiries and want to automate the initial response process using AI. If you spend too much time answering similar questions, this system helps respond faster and more intelligently—without writing a single line of code.\n\n---\n\n### What problem is this workflow solving?\n\nManually responding to repeated customer enquiries slows productivity and increases delay. This workflow classifies if an incoming email is a real enquiry, analyzes the content with a LangChain-powered agent, fetches helpful context using Dumpling AI, and sends a personalized reply using Gmail—all within minutes.\n\n---\n\n### What this workflow does\n\n1. **Listens for new incoming Gmail messages** using the Gmail Trigger node.  \n2. **Classifies whether the email is an enquiry** using a GPT-4o classification prompt.  \n3. **Uses a Filter node** to continue only if the email was classified as an enquiry.  \n4. **Passes the email content to a LangChain Agent**, enhanced with memory, AI tools, and Dumpling AI to search for relevant information.  \n5. **The agent constructs a smart, relevant response**, then sends it to the original sender via Gmail.\n\n---\n\n### Setup\n\n1. **Connect Gmail**  \n   - Use the Gmail Trigger node to connect to the Gmail account that receives enquiries.  \n   - Make sure Gmail OAuth2 credentials are authenticated.\n\n2. **Configure Dumpling AI Agent**  \n   - Sign up at [Dumpling AI](https://www.dumplingai.com/).  \n   - Create an agent trained to search your help docs, site content, or FAQs.  \n   - Copy your Dumpling agent ID and API key.  \n   - Paste it in the `Dumpling AI Agent – Search for Relevant Info` HTTP Request node.\n\n3. **Set Up LangChain Agent**  \n   - No extra setup needed beyond connecting OpenAI credentials.  \n   - GPT-4o is used for classification and reply generation.\n\n4. **Enable Gmail Reply Node**  \n   - The final `Send Email Response via Gmail` node will send the AI-generated reply back to the same thread.\n\n---\n\n### How to customize this workflow to your needs\n\n- Change the classification prompt to include other email types like “support”, “complaint”, or “sales”.  \n- Add additional logic if you want to CC someone or forward certain types of enquiries.  \n- Add a Notion or Google Sheets node to log the conversation for analytics.  \n- Replace Gmail with Outlook or another email provider by switching the nodes.  \n- Improve context by adding more AI tools like database queries or preloaded FAQs.\n",
+			"nodes": [
+				"n8n-nodes-base.gmailTrigger",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.filter",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.toolHttpRequest",
+				"n8n-nodes-base.gmailTool",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:langchain"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 85.82,
+			"scoreBreakdown": {
+				"traction": 0.541,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4057",
+			"author": "yang",
+			"success": true
+		},
+		{
+			"id": 3336,
+			"slug": "automate-blog-content-creation-with-gpt-4-perplexity-wordpre-3336",
+			"name": "Automate Blog Content Creation with GPT-4, Perplexity & WordPress",
+			"description": "![Workflow Screenshot](https://www.dr-firas.com/workflow-tool.png)  \n\n# Who Is This For\n\nThis workflow is ideal for content creators, solo founders, marketers, and AI enthusiasts who want to automate the full process of blog content creation.  \nIt is especially useful for professionals in tech, AI, and automation who publish frequently and need SEO-ready content fast.\n\n# What Problem Does This Workflow Solve\n\n- Creating SEO-optimized blog content is time-consuming and requires consistency.  \n- Manually researching trending topics slows down the content pipeline.  \n- Formatting, publishing, and promoting across multiple platforms takes effort.  \n- This workflow automates the entire process from research to publication.\n\n# What This Workflow Does\n\n- Research: Uses Perplexity AI to gather up-to-date content ideas via form input.  \n- Content Generation: GPT-4 creates a short, SEO-optimized article (max 20 lines) with H1, H2 structure and meta-description.  \n- Publishing: Automatically posts the content to WordPress.  \n- Email Notification: Sends the article title and URL via Gmail.  \n- Slack Notification: Notifies a specified Slack channel when the article is live.  \n- Database Logging: Saves the article details to a Notion database.\n\n# Setup Guide\n\n## Prerequisites\n\n- WordPress account with API access  \n- OpenAI API Key  \n- Perplexity API Key  \n- Slack Bot Token  \n- Notion integration (Database ID)  \n- Gmail API credentials (optional)  \n- Community Node Required: This workflow uses `n8n-nodes-mcp`, which only works on self-hosted instances of n8n.  \n  &gt; To install: Go to *Settings &gt; Community Nodes &gt; Install `n8n-nodes-mcp`*\n\n## Steps\n\n1. Import the workflow into your n8n instance  \n2. Install the required community node (`n8n-nodes-mcp`)  \n3. Set up API credentials for OpenAI, Perplexity, WordPress, Slack, Gmail, and Notion  \n4. Customize the form trigger with your preferred prompt  \n5. Run a test using a sample topic\n\n# How to Customize This Workflow\n\n- Modify the research prompt to match your niche or industry  \n- Adjust GPT-4 settings for tone, structure, or content length  \n- Customize Notion fields (e.g., add tags, categories, or labels)  \n- Add logic for generating or assigning featured images automatically",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-mcp.mcpClientTool",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.wordpressTool",
+				"n8n-nodes-base.gmailTool",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.formTrigger"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:mcpClientTool"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 85.81,
+			"scoreBreakdown": {
+				"traction": 0.617,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.692
+			},
+			"source": "https://n8n.io/workflows/3336",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 4108,
+			"slug": "ai-image-generator-from-text-built-on-fal-ai-4108",
+			"name": "AI image generator from text built on fal.ai",
+			"description": "## Who this template is for\n\nThis template is for developers, content creators, or application builders who want to integrate an AI-powered text-to-image generation service into their applications or systems via an API endpoint.\n\n## Use case\n\nCreating a secure API endpoint that converts text prompts into AI-generated images, with built-in content moderation to prevent inappropriate content generation. This can be used for creative applications, content creation tools, prototyping interfaces, or any system that needs on-demand image generation.\n\n## How this workflow works\n\n1. Receives text prompt through a webhook endpoint\n2. Filters the prompt for inappropriate content using AI moderation\n3. Submits valid prompts to the Fal.ai Flux image generation service\n4. Polls for completion status and retrieves the generated image when ready\n5. Returns the image results in a structured JSON format to the client\n\n## Set up steps\n\n1. Create a Fal.ai account and obtain API credentials\n2. Configure the HTTP Header Auth credentials with your Fal.ai API key\n3. Set up an OpenAI API key for the content moderation component\n4. Deploy the workflow and note the webhook URL for your API endpoint\n5. Test the endpoint by sending a POST request with a JSON body containing a \"prompt\" field",
+			"nodes": [
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.if",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.respondToWebhook",
+				"@n8n/n8n-nodes-langchain.textClassifier",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:httpRequest"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 85.79,
+			"scoreBreakdown": {
+				"traction": 0.614,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.7
+			},
+			"source": "https://n8n.io/workflows/4108",
+			"author": "n8n-team",
+			"success": true
+		},
+		{
+			"id": 5157,
+			"slug": "automate-daily-ai-news-with-perplexity-sonar-pro-via-telegra-5157",
+			"name": "Automate Daily AI News with Perplexity Sonar Pro (via Telegram)",
+			"description": "*This workflow contains community nodes that are only compatible with the self-hosted version of n8n.* \n\n🧠 Perplexity-Powered Daily AI News Digest (via Telegram)\n\n\nThis ready-to-deploy n8n workflow automates the entire process of collecting, filtering, formatting, and distributing daily AI industry news summaries directly to your Telegram group or channel.\n\nPowered by Perplexity and OpenAI, it fetches only high-signal AI updates from trusted sources (e.g. OpenAI, DeepMind, HuggingFace, MIT Tech Review), filters out duplicates based on a Google Sheet archive, and delivers beautifully formatted news directly to your team — every morning at 10AM.\n\nFor more such build and step-by-step tutorials, check out:\nhttps://www.youtube.com/@Automatewithmarc\n\n🚀 Key Features:\nPerplexity AI Integration: Automatically fetches the most relevant AI developments from the last 24 hours.\n\nAI Formatter Agent: Cleans the raw feed, removes duplicates, adds summaries, and ensures human-friendly formatting.\n\nGoogle Sheets Log: Tracks previously reported news items to avoid repetition.\n\nTelegram Delivery: Sends a polished daily digest straight to your chat, ready for immediate team consumption.\n\nCustomizable Scheduling: Preconfigured for daily use, but can be modified to fit your team's preferred cadence.\n\n💼 Ideal For:\nAnyone who wants to stay ahead of fast-moving AI trends with zero manual effort\n\n🛠️ Tech Stack:\nPerplexity AI\n\nOpenAI (GPT-4 or equivalent)\n\nGoogle Sheets\n\nTelegram API\n\n✅ Setup Notes:\nYou’ll need to connect your own OpenAI, Perplexity, Google Sheets, and Telegram credentials.\n\nReplace the Google Sheet ID and Telegram channel settings with your own.",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.googleSheetsTool",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.perplexity",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.telegram"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:googleSheetsTool"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 85.73,
+			"scoreBreakdown": {
+				"traction": 0.537,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5157",
+			"author": "marconi",
+			"success": true
+		},
+		{
+			"id": 3657,
+			"slug": "build-a-chatbot-voice-and-phone-agent-with-voiceflow-google--3657",
+			"name": "Build a Chatbot, Voice and Phone Agent with Voiceflow, Google Calendar and RAG",
+			"description": "**Voiceflow** is a no-code platform that allows you to design, prototype, and deploy conversational assistants across multiple channels—such as **chat**, **voice**, and **phone**—with advanced logic and natural language understanding. It supports integration with APIs, webhooks, and even tools like Twilio for phone agents. It's perfect for building customer support agents, voice bots, or intelligent assistants.\n\nThis workflow connects **n8n** and **Voiceflow** with tools like **Google Calendar**, **Qdrant (vector database)**, **OpenAI**, and an **order tracking API** to power a smart, multi-channel conversational agent.\n\n![image](https://i.postimg.cc/3rSPwMn2/langflow.png)\n\nThere are 3 main webhook endpoints in n8n that Voiceflow interacts with:\n\n1. **`n8n_order`** – receives user input related to order tracking, queries an API, and responds with tracking status.\n2. **`n8n_appointment`** – processes appointment booking, reformats date input using OpenAI, and creates a Google Calendar event.\n3. **`n8n_rag`** – handles general product/service questions using a RAG (Retrieval-Augmented Generation) system backed by:\n   - **Google Drive** document ingestion,\n   - **Qdrant vector store** for search,\n   - and **OpenAI** models for context-based answers.\n\nEach webhook is connected to a corresponding **\"Capture\" block** inside Voiceflow, which sends data to n8n and waits for the response.\n\n---\n\n### **How It Works**  \nThis n8n workflow integrates **Voiceflow** for chatbot/voice interactions, **Google Calendar** for appointment scheduling, and **RAG (Retrieval-Augmented Generation)** for knowledge-based responses. Here’s the flow:  \n\n- **Trigger**:  \n  - Three webhooks (`n8n_order`, `n8n_appointment`, `n8n_rag`) receive inputs from Voiceflow (chat, voice, or phone calls).  \n  - Each webhook routes requests to specific functions:  \n    - **Order Tracking**: Fetches order status via an external API.  \n    - **Appointment Scheduling**: Uses OpenAI to parse dates, creates Google Calendar events, and confirms via WhatsApp.  \n    - **RAG System**: Queries a Qdrant vector store (populated with Google Drive documents) to answer customer questions using GPT-4.  \n\n- **AI Processing**:  \n  - **OpenAI Chains**: Convert natural language dates to Google Calendar formats and generate responses.  \n  - **RAG Pipeline**: Embeds documents (via OpenAI), stores them in Qdrant, and retrieves context-aware answers.  \n  - **Voiceflow Integration**: Routes responses back to Voiceflow for multi-channel delivery (chat, voice, or phone).  \n\n- **Outputs**:  \n  - Confirmation messages (e.g., \"Event created successfully\").  \n  - Dynamic responses for orders, appointments, or product support. \n\n---\n\n### **Setup Steps**  \n\n##### **Prerequisites**:  \n- **APIs**:  \n  - Google Calendar & Drive OAuth credentials.  \n  - Qdrant vector database (hosted or cloud).  \n  - OpenAI API key (for GPT-4 and embeddings).  \n\n##### **Configuration**:  \n1. **Qdrant Setup**:  \n   - Run the **\"Create collection\"** and **\"Refresh collection\"** nodes to initialize the vector store.  \n   - Populate it with documents using the **Google Drive → Qdrant** pipeline (embeddings generated via OpenAI).  \n\n2. **Voiceflow Webhooks**:  \n   - Link Voiceflow’s \"Captures\" to n8n’s webhook URLs (`n8n_order`, `n8n_appointment`, `n8n_rag`).  \n\n3. **Google Calendar**:  \n   - Authenticate the **Google Calendar node** and set event templates (e.g., `summary`, `description`).  \n\n4. **RAG System**:  \n   - Configure the **Qdrant vector store** and **OpenAI embeddings** nodes.  \n   - Adjust the **Retrieve Agent**’s system prompt for domain-specific queries (e.g., electronics store support).   \n\n#### **Optional**:  \n- Add Twilio for phone-agent capabilities.  \n- Customize OpenAI prompts for tone/accuracy.  \n\n![image](https://i.postimg.cc/855gyTZP/voiceflow-agent.png)\n![image](https://i.postimg.cc/5Nn4Sk43/voiceflow-agent2.png)\n\nPS. You can import a Twilio number to assign it to your agent for becoming a Phone Agent\n\n![image](https://i.postimg.cc/cLymTTFv/voiceflow-agent3.png)\n\n---\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/)",
+			"nodes": [
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.googleCalendar",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"@n8n/n8n-nodes-langchain.vectorStoreQdrant",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.toolVectorStore",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.respondToWebhook",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterTokenSplitter"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:langchain"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 85.67,
+			"scoreBreakdown": {
+				"traction": 0.641,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.571
+			},
+			"source": "https://n8n.io/workflows/3657",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 10358,
+			"slug": "automate-ai-video-creation-multi-platform-publishing-with-gp-10358",
+			"name": "Automate AI Video Creation & Multi-Platform Publishing with GPT-4, Veo 3.1 & Blotato",
+			"description": "# 💥 Automate AI Video Creation & Multi-Platform Publishing with Veo 3.1 & Blotato\n\n![Workflow Overview](https://www.dr-firas.com/veo31.png)\n\n### 🎯 Who is this for?\nThis workflow is designed for **content creators, marketers, and automation enthusiasts** who want to produce professional AI-generated videos and publish them automatically on social media — without editing or manual uploads. Perfect for those using **Veo 3.1**, **GPT-4**, and **Blotato** to scale video creation.\n\n---\n\n### 💡 What problem is this workflow solving?\nCreating short-form content (TikTok, Instagram Reels, YouTube Shorts) is time-consuming — from writing scripts to video editing and posting.  \nThis workflow eliminates the manual steps by combining **AI storytelling + video generation + automated publishing**, letting you focus on creativity while your system handles production and distribution.\n\n---\n\n### ⚙️ What this workflow does\n1. **Reads new ideas from Google Sheets**  \n2. **Generates story scripts** using GPT-4  \n3. **Creates cinematic videos** using Veo 3.1 (`fal.ai/veo3.1/reference-to-video`) with 3 input reference images  \n4. **Uploads the final video** automatically to Google Drive  \n5. **Publishes the video** across multiple platforms (TikTok, Instagram, Facebook, X, LinkedIn, YouTube) via **Blotato**  \n6. **Updates Google Sheets** with video URL and status (Completed / Failed)\n\n---\n\n### 🧩 Setup\n**Required accounts:**\n- [OpenAI](https://platform.openai.com/api-keys) → GPT-4 API key  \n- [fal.ai](https://fal.ai/dashboard/keys) → Veo 3.1 API key  \n- [Google Cloud Console](https://console.cloud.google.com) → Sheets & Drive connection  \n- [Blotato](https://blotato.com/?ref=firas) → API key for social media publishing  \n\n**Configuration steps:**\n1. Copy the **Google Sheets structure**:  \n   - A: `id_video`  \n   - B: `niche`  \n   - C: `idea`  \n   - D: `url_1`  \n   - E: `url_2`  \n   - F: `url_3`  \n   - G: `url_final`  \n   - H: `status`  \n\n2. Add your API keys to the **Workflow Configuration** node.  \n3. Insert three image URLs and a short idea into your sheet.  \n4. Wait for the automation to process and generate your video.  \n\n---\n\n### 🧠 How to customize this workflow\n- **Change duration or aspect ratio** → Edit the Veo 3.1 node JSON body (`duration`, `aspect_ratio`)  \n- **Modify prompt style** → Adjust the “Optimize Prompt for Veo” node for your desired tone or cinematic look  \n- **Add more platforms** → Extend Blotato integration to publish on Pinterest, Reddit, or Threads  \n- **Enable Telegram Trigger** → Allow users to submit ideas and images directly via Telegram  \n\n---\n\n### 🚀 Expected Outcome\nWithin **2–3 minutes**, your idea is transformed into a full cinematic AI video — complete with storytelling, visuals, and automatic posting to your social media channels.  \n\nSave hours of editing and focus on strategy, creativity, and growth.\n\n---\n\n### 👋 Need help or want to customize this?\n📩 Contact: [LinkedIn](https://www.linkedin.com/in/dr-firas/)  \n📺 YouTube: [@DRFIRASS](https://www.youtube.com/@DRFIRASS)  \n🚀 Workshops: [Mes Ateliers n8n](https://hotm.art/formation-n8n)\n\n---\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/Automate-AI-Video-Creation-Multi-Platform-Publishing-with-Veo-3-1-Blotato-29c3d6550fd981cd982fd4a031bdfe07?source=copy_link)\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https://www.youtube.com/channel/UCriIQI8uaoEro5FEnOpeidQ) / [🚀 Mes Ateliers n8n  ](https://hotm.art/formation-n8n)",
+			"nodes": [
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.googleSheetsTrigger",
+				"n8n-nodes-base.stickyNote",
+				"@blotato/n8n-nodes-blotato.blotato",
+				"n8n-nodes-base.merge"
+			],
+			"tags": ["trigger:other", "ai", "integration:blotato"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 85.6,
+			"scoreBreakdown": {
+				"traction": 0.673,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.429
+			},
+			"source": "https://n8n.io/workflows/10358",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 4573,
+			"slug": "google-maps-business-scraper-with-contact-extraction-via-api-4573",
+			"name": "Google Maps business scraper with contact extraction via Apify and Firecrawl",
+			"description": "## Who is this for?\nMarketing agencies, sales teams, lead generation specialists, and business development professionals who need to build comprehensive business databases with contact information for outreach campaigns across any industry.\n\n## What problem is this workflow solving?\nFinding businesses and their contact details manually is time-consuming and inefficient. This workflow automates the entire process of discovering businesses through Google Maps and extracting their digital contact information from websites, saving hours of manual research.\n\n## What this workflow does\nThis automated workflow runs every 30 minutes to:\n- Scrape business data from Google Maps using Apify's Google Places crawler\n- Save basic business information (name, address, phone, website) to Google Sheets\n- Filter businesses that have websites\n- Scrape each business's website content using Firecrawl\n- Extract contact information including emails, LinkedIn, Facebook, Instagram, and Twitter profiles\n- Store all extracted data in organized Google Sheets for easy access and follow-up\n\n## Setup\n**Required Services:**\n- Google Sheets account with OAuth2 setup\n- Apify account with API access for Google Places scraping\n- Firecrawl account with API access for website scraping\n\n**Pre-setup:**\n1. Copy this [Google Sheet](https://docs.google.com/spreadsheets/d/1DHezdcetT0c3Ie1xB3z3jDc5WElsLN87K4J9EQDef9g/edit?usp=sharing)\n2. Configure your Apify and Firecrawl API credentials in n8n\n3. Set up Google Sheets OAuth2 connection\n4. Update the Google Sheet ID in all Google Sheets nodes\n\n**Quick Start:**\nThe workflow includes detailed sticky notes explaining each phase. Simply configure your API credentials and Google Sheet, then activate the workflow.\n\n## How to customize this workflow to your needs\n- **Change search criteria**: Modify the Apify scraping parameters to target different business types (restaurants, gyms, salons, etc.) or locations\n- **Adjust schedule**: Change the trigger interval from 30 minutes to your preferred frequency  \n- **Add more contact fields**: Extend the extraction code to find additional contact information like WhatsApp or Telegram\n- **Filter criteria**: Modify the filter conditions to target businesses with specific characteristics\n- **Batch size**: Adjust the batch processing to handle more or fewer websites simultaneously\n\nPerfect for lead generation, competitor research, and building targeted marketing lists across any industry or business type.",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "integration:googleSheets"],
+			"triggerType": "schedule",
+			"hasAI": false,
+			"score": 85.48,
+			"scoreBreakdown": {
+				"traction": 0.631,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.571
+			},
+			"source": "https://n8n.io/workflows/4573",
+			"author": "n8nstein",
+			"success": true
+		},
+		{
+			"id": 5303,
+			"slug": "google-search-console-and-analytics-analysis-with-ai-optimiz-5303",
+			"name": "Google Search Console and Analytics Analysis with AI Optimizations",
+			"description": "## What Is This?\n\nThis workflow is a comprehensive solution for automating website audits and optimizations, leveraging advanced technologies to boost SEO effectiveness and overall site performance.\n\n## Who Is It For?\n\nDesigned for SEO specialists, digital marketers, webmasters, and content teams, this workflow empowers anyone responsible for website performance to automate and scale their audit processes. Agencies managing multiple client sites, in-house SEO teams aiming to save time on routine checks, and developers seeking to integrate data-driven insights into their deployment pipelines will all find this solution invaluable.\n\nBy combining your site’s sitemap with Google Search Console and Google Analytics data, then applying AI-powered analysis, the workflow continuously uncovers actionable recommendations to boost search visibility, improve user engagement, and accelerate page performance. Whether you manage a single blog or oversee a sprawling e-commerce platform, this automated pipeline delivers precise, prioritized SEO improvements without manual data wrangling.\n\n## How Does It Work?\n\nThis end-to-end site analysis automation consists of five main stages:\n\n**1. URL Discovery**  \nProcesses the sitemap.xml using HTTP Request and XML nodes to extract all site URLs.\n\n**2. Search Console Performance Analysis**  \nUses the Google Search Console API to fetch detailed metrics for each page, including search position, clicks, impressions, and CTR. \n\n**3. Analytics Data Collection**  \nConnects to the Google Analytics API to automatically retrieve traffic metrics such as pageviews, average session duration, bounce rate, and conversions. \n\n**4. AI Data Processing**  \nEmploys OpenAI models to perform in-depth analysis of the collected data. The artificial intelligence engine merges insights from all sources, identifies patterns, and produces detailed optimization recommendations. AI analyses website itsefl aswell. **Consider testing different models**. I do recommend at least trying out o4-mini.\n\n**5. Recommendation Generation**  \nCreates tailored suggestions for each page, in form of HTML table, that is being sent to your email.\n\n## How To Set It Up?\n\n**Accounts:**  \nAn active n8n account or instance, API keys for Google Search Console and Google Analytics, an OpenAI access token.\n\n**Enabled Google APIs:**\nYou will neeed at least following scopes:\n- Google Search Console API\n- Google Analytics Aadmin API\n- Google Analytics Data API \n\n**Scheduling:**  \nThe workflow can run manually for ad hoc audits or be scheduled (daily, weekly) for continuous site monitoring.\n\n**Testing:**  \nThere are two nodes that are optional:\n- \"Sort for testing purposes\" and\n- \"Limit for testing purposes\"\nTogether they randomly select items from sitemap and limit them to few so you don't need to run hundreds of sitemap.xml items at once, but you can run just a random batch first.\n\n**Globals:**\nThere is node called \"Globals- CHANGE ME!\". You need to set up proper variables in there, which are:\n- sitemap_url - self exlpainatory\n- search_console_selector - for example \"sc-domain:sailingbyte.com\" but can be URL aswell- depends on how did you set up your search console\n- analysis_start_date and analysis_end_date - date range for analytics, by default last 30 days\n- analytics_selector_id - ID of Google Analytics setup, it is a large integer, you can find it in analytics url preceeded with letter \"p\", ex (your number is where there are X's): https://analytics.google.com/analytics/web/#/pXXXXXXXXX/reports/intelligenthome\n- report_receiver - email which will receive report \n\n## What's More?\n\nThat's actually it. I hope that this automation will help your website improvement will be much easier!\n\n## Thank you, perfect!\n\nGlad I could help. Visit my profile for other automations for businesses. And if you are looking for dedicated software development, do not hesitate to reach out!",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.removeDuplicates",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.xml",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.limit",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.googleAnalytics",
+				"n8n-nodes-base.httpRequestTool",
+				"n8n-nodes-base.markdown",
+				"n8n-nodes-base.html",
+				"n8n-nodes-base.emailSend",
+				"n8n-nodes-base.sort",
+				"@n8n/n8n-nodes-langchain.agent"
+			],
+			"tags": ["trigger:manual", "ai", "integration:merge"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 85.4,
+			"scoreBreakdown": {
+				"traction": 0.574,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.783
+			},
+			"source": "https://n8n.io/workflows/5303",
+			"author": "lukaszpp",
+			"success": true
+		},
+		{
+			"id": 11047,
+			"slug": "automated-ai-music-generation-with-elevenlabs-google-sheets--11047",
+			"name": "Automated 🤖🎵 AI Music Generation with ElevenLabs, Google Sheets & Drive",
+			"description": "🤖🎵 This workflow automates the creation, storage, and cataloging of AI-generated music using the **[Eleven Music API](https://try.elevenlabs.io/ahkbf00hocnu)**, **Google Sheets**, and **Google Drive**.\n\n---\n### **Key Advantages**\n✅ **Fully Automated Music Generation Pipeline**\n\nOnce started, the workflow automatically:\n\n* Reads track parameters\n* Generates music via API\n* Uploads the file\n* Updates your spreadsheet\n  No manual steps needed after initialization.\n\n✅ **Centralized Track Management**\n\nA single Google Sheet acts as your **project control center**, letting you organize:\n\n* Prompts\n* Durations\n* Generated URLs\n  This avoids losing track of files and creates a ready-to-share catalog.\n\n✅ **Seamless Integration with Google Services**\n\nThe workflow:\n\n* Reads instructions from **Google Sheets**\n* Saves the MP3 to **Google Drive**\n* Updates the same Sheet with the final link\n  This ensures everything stays synchronized and easy to access.\n\n✅ **Scalable and Reliable Processing**\n\nThe loop-with-delay mechanism:\n\n* Processes tracks sequentially\n* Prevents API overload\n* Ensures stable execution\n  This is especially helpful when generating multiple long tracks.\n\n✅ **Easy Customization**\n\nBecause the prompts and durations come from Google Sheets:\n\n* You can edit prompts at any time\n* You can add more tracks without modifying the workflow\n* You can clone the Sheet for different projects\n\n✅ **Ideal for Creators and Businesses**\n\nThis workflow is perfect for:\n\n* Content creators generating background music\n* Agencies designing custom soundtracks\n* Businesses needing AI-generated audio assets\n* Automated production pipelines\n\n---\n\n### How It Works\n\nThe process operates as follows:\n\n- The workflow starts manually via the \"Execute workflow\" trigger\n- It retrieves a list of music track requests from a Google Sheets spreadsheet containing track titles, text prompts, and duration specifications\n- The system processes each track request individually through a batch loop\n- For each track, it sends the text prompt and duration to ElevenLabs Music API to generate studio-quality music\n- The generated MP3 file (in 44100 Hz, 128 kbps format) is automatically uploaded to a designated Google Drive folder\n- Once uploaded, the workflow updates the original Google Sheets with the direct URL to the generated music file\n- A 1-minute wait period between each track generation prevents API rate limiting\n- The process continues until all track requests in the spreadsheet have been processed\n\n---\n\n### Set Up Steps\n\n**Prerequisites:**\n- ElevenLabs paid account with Music API access enabled\n- Google Sheets spreadsheet with specific columns: TITLE, PROMPT, DURATION (ms), URL\n- Google Drive folder for storing generated music files\n\n**Configuration Steps:**\n\n1. **ElevenLabs API Setup:**\n   - Enable Music Generation access in your  [ElevenLabs account](https://try.elevenlabs.io/ahkbf00hocnu)\n   - Generate an API key from the ElevenLabs developer dashboard\n   - Configure HTTP Header authentication in n8n with name \"xi-api-key\" and your API value\n\n2. **Google Sheets Preparation:**\n   - Create or clone the music tracking spreadsheet with required columns\n   - Fill in track titles, detailed text prompts, and durations in milliseconds (10,000-300,000 ms)\n   - Configure Google Sheets OAuth credentials in n8n\n   - Update the document ID in the Google Sheets nodes\n\n3. **Google Drive Configuration:**\n   - Create a dedicated folder for music uploads\n   - Set up Google Drive OAuth credentials in n8n\n   - Update the folder ID in the upload node\n\n4. **Workflow Activation:**\n   - Ensure all API credentials are properly configured\n   - Test with a single track entry in the spreadsheet\n   - Verify music generation, upload, and spreadsheet update work correctly\n   - Execute the workflow to process all pending track requests\n\nThe workflow automatically names files with timestamp prefixes (song_yyyyMMdd) and handles the complete lifecycle from prompt to downloadable music file.\n\n---\n\n👉 [Subscribe to my new **YouTube channel**](https://youtube.com/@n3witalia). Here I’ll share videos and Shorts with practical tutorials and **FREE templates for n8n**.\n\n[![image](https://n3wstorage.b-cdn.net/n3witalia/youtube-n8n-cover.jpg)](https://youtube.com/@n3witalia)\n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/).",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive"
+			],
+			"tags": ["trigger:manual", "integration:googleSheets"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 85.32,
+			"scoreBreakdown": {
+				"traction": 0.551,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.857
+			},
+			"source": "https://n8n.io/workflows/11047",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4457,
+			"slug": "ai-telegram-bot-agent-smart-assistant-content-summarizer-4457",
+			"name": "AI Telegram Bot Agent: Smart Assistant & Content Summarizer",
+			"description": "\n**Create your own intelligent Telegram bot that summarizes articles and processes commands automatically.**\n\nThis powerful workflow turns Telegram into your personal AI assistant, handling `/help`, `/summary &lt;URL&gt;`, and `/img &lt;prompt&gt;` commands with intelligent responses - perfect for teams, content creators, and anyone wanting smart automation in their messaging.\n\n## 🚀 What It Does\n\n**Smart Command Processing**: Automatically recognizes and routes `/help`, `/summary`, and `/img` commands to appropriate AI-powered responses.\n\n**Article Summarization**: Fetches any URL, extracts content, and generates professional 10-12 bullet point summaries using OpenAI.\n\n**Image Generation**: Processes image prompts and integrates with AI image generation services.\n\n**Help System**: Provides users with clear command instructions and usage examples.\n\n## 🎯 Key Benefits\n\n✅ **Personal AI Assistant**: Get instant article summaries in Telegram  \n✅ **Team Productivity**: Share quick content summaries with colleagues  \n✅ **Content Research**: Rapidly digest articles and web content  \n✅ **24/7 Availability**: Bot works around the clock without maintenance  \n✅ **Easy Commands**: Simple `/summary &lt;link&gt;` format anyone can use  \n✅ **Scalable**: Handles multiple users and requests simultaneously  \n\n## 🏢 Perfect For\n\n### **Content Teams & Researchers**\n- Journalists quickly summarizing news articles\n- Marketing teams researching competitor content\n- Students processing academic papers and articles\n- Analysts digesting industry reports\n\n### **Business Applications**\n- **Team Communication**: Share article insights in group chats\n- **Research Assistance**: Quick content analysis for decision making\n- **Content Curation**: Summarize articles for newsletters or reports\n- **Knowledge Sharing**: Help teams stay informed efficiently\n\n## ⚙️ What's Included\n\n**Complete Bot Workflow**: Ready-to-deploy Telegram bot with all commands\n**AI Integration**: OpenAI-powered content summarization and processing\n**Smart Routing**: Intelligent command recognition and response system\n**Error Handling**: Robust system handles invalid commands gracefully\n**Extensible Design**: Easy to add new commands and features\n\n## 🔧 Quick Setup Requirements\n\n- **n8n Platform**: Cloud or self-hosted instance\n- **Telegram Bot Token**: Create via @BotFather (free, 5 minutes)\n- **OpenAI API**: For content summarization (pay-per-use)\n- **Basic Configuration**: Follow 15-minute setup guide\n\n## 📱 User Experience\n\n**Simple Commands:**\n```\n/help - Show available commands\n/summary https://example.com - Get article summary\n/img sunset over mountains - Generate image (with supported APIs)\n```\n\n**Sample Summary Output:**\n```\n📄 Article Summary:\n\n• Company reports 40% revenue growth in Q3 2024\n• New AI features driving customer acquisition\n• Expansion into European markets planned for 2025\n• Investment in R&D increased by 25% this quarter\n• Customer satisfaction scores improved to 94%\n• Three new product launches scheduled for next year\n• Remote work policy made permanent post-pandemic\n• Sustainability goals on track to meet 2025 targets\n• Partnership with major tech firm announced\n• Stock price up 15% following earnings report\n```\n\n## 🎨 Customization Options\n\n**Command Extensions**: Add custom commands for specific workflows\n**Response Formatting**: Customize summary style and length\n**Multi-Language**: Support different languages for international teams\n**Integration APIs**: Connect additional AI services and tools\n**User Permissions**: Control who can use specific commands\n**Analytics**: Track usage patterns and popular content\n\n## 🏷️ Tags & Categories\n\n`#telegram-bot` `#ai-automation` `#content-summarization` `#article-processing` `#team-productivity` `#openai-integration` `#smart-assistant` `#workflow-automation` `#messaging-bot` `#content-research` `#ai-agent` `#n8n-workflow` `#business-automation` `#telegram-integration` `#ai-powered-bot`\n\n## 💡 Use Case Examples\n\n**News Team**: Quickly summarize breaking news articles for editorial meetings\n**Marketing Agency**: Research competitor content and industry trends efficiently  \n**Sales Team**: Digest industry reports and share insights with prospects\n**Remote Team**: Keep everyone informed with summarized company updates\n\n## 📈 Expected Results\n\n- **80% faster** content research and analysis\n- **50% more articles** processed per day vs manual reading\n- **100% team accessibility** through familiar Telegram interface\n- **24/7 availability** for global teams across time zones\n\n## 🛠️ Setup & Support\n\n**Quick Start**: Deploy your bot in 15 minutes with included guide\n**Video Tutorial**: Complete walkthrough available\n**Template Commands**: Pre-built responses and formatting\n**Expert Support**: Direct help from workflow creator\n\n## 📞 Get Help & Resources\n\nYouTube: [https://www.youtube.com/@YaronBeen/videos](https://www.youtube.com/@YaronBeen/videos)\n\n**💼 Professional Support**  \nLinkedIn: [https://www.linkedin.com/in/yaronbeen/](https://www.linkedin.com/in/yaronbeen/)\n\n**📧 Direct Help**  \nEmail: Yaron@nofluff.online - Response within 24 hours\n\n---\n\n**Ready to build your intelligent Telegram assistant?**\n\nGet this AI Telegram Bot Agent and transform your messaging app into a powerful content processing tool. Perfect for teams, researchers, and anyone who wants AI-powered assistance directly in Telegram.\n\n*Stop manually reading long articles. Start getting instant, intelligent summaries with simple commands.*",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.html",
+				"@n8n/n8n-nodes-langchain.openAi"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:if"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 85.31,
+			"scoreBreakdown": {
+				"traction": 0.629,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.545
+			},
+			"source": "https://n8n.io/workflows/4457",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 3669,
+			"slug": "publish-image-video-to-multiple-social-media-x-instagram-fac-3669",
+			"name": "Publish image & video to multiple social media (X, Instagram, Facebook and more)",
+			"description": "This Workflow streamlines the process of publishing posts (**image or video**) to multiple social media platforms using a unified form and a third-party API service called Upload-Post.\n\nThe automation starts with a form trigger, allowing users to submit content (text and media) through a simple frontend interface. Users select the platform (**Instagram, LinkedIn, Facebook, X, TikTok, Threads**), choose the profile name, write a caption, and upload a photo or video.\n\n---\n\n### **How It Works**  \nAutomates cross-platform social media posting via Upload-Post, handling both **images** (JPEG) and **videos** (MP4). Here’s the process:  \n\n- **Trigger**:  \n  - A **form submission** captures user inputs:  \n    - **Platform** (Instagram, LinkedIn, Facebook, X, TikTok, Threads).  \n    - **Account** (pre-configured profile name).  \n    - **Caption** and **file** (image/video).  \n    - Optional **Facebook Page ID** for targeted posting.  \n\n- **Routing**:  \n  - The **\"Video or Photo?\"** Switch node checks the file’s MIME type:  \n    - **Image**: Routes to the **\"Post photo\"** HTTP node (uploads via `upload_photos` API).  \n    - **Video**: Routes to the **\"Post video\"** HTTP node (uploads via `upload` API).  \n\n- **API Integration**:  \n  - Both nodes send data to Upload-Post.com’s API, including:  \n    - Caption, account name, platform, and file binary.  \n    - Facebook ID (if provided).  \n\n- **Success/Failure Handling**:  \n  - The **\"Result Photo/Video\"** nodes parse the API response.  \n\n---\n\n### **Setup Steps**  \n\n##### **Prerequisites**:  \n- **Upload-Post.com API Key**:  \n  - Get it from the [API Keys dashboard](https://www.upload-post.com/?linkId=lp_144414&sourceId=n3witalia&tenantId=upload-post-app).  \n  - Free tier allows **10 uploads/month**.  \n\n##### **Configuration**:  \n1. **API Authentication**:  \n   - In the **HTTP Request nodes** (`Post photo`/`Post video`), set the `Authorization` header:  \n     - `Name`: `Authorization`  \n     - `Value`: `Apikey YOUR_API_KEY_HERE`.  \n\n2. **Form Customization**:  \n   - Adjust the **\"On form submission\"** node to:  \n     - Add/remove platforms (e.g., YouTube when approved).  \n     - Modify file type restrictions (default: `.jpg`, `.mp4`).  \n\n3. **Account Mapping**:  \n   - Ensure the **\"Account\"** field matches profiles configured in Upload-Post.com (e.g., `test1`, `test2`).  \n\n4. **Facebook Page Integration**:  \n   - Optional: Add a **Facebook Page ID** field for page-specific posts.  \n\n5. **Testing**:  \n   - Submit test forms with images/videos.  \n   - Verify API responses and success/failure messages.  \n\n##### **Optional Enhancements**:  \n- Add **error logging** (e.g., save failed attempts to a database).  \n- Extend to **YouTube** once API support is confirmed.  \n\n---\n\n### **Key Features**:  \n- **Multi-Platform**: Post to 6+ social networks simultaneously.  \n- **User-Friendly**: Simple form interface for non-technical users.  \n- **Error Handling**: Clear feedback for success/failure cases.  \n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.form",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:formTrigger", "integration:form"],
+			"triggerType": "formTrigger",
+			"hasAI": false,
+			"score": 85.3,
+			"scoreBreakdown": {
+				"traction": 0.64,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.5
+			},
+			"source": "https://n8n.io/workflows/3669",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4731,
+			"slug": "automated-investor-intelligence-crunchbase-to-google-sheets--4731",
+			"name": " Automated Investor Intelligence: CrunchBase to Google Sheets Data Harvester",
+			"description": "# 🚀 Automated Investor Intelligence: CrunchBase to Google Sheets Data Harvester!\n\n## Workflow Overview\nThis cutting-edge n8n automation is a sophisticated investor intelligence tool designed to transform market research into actionable insights. By intelligently connecting CrunchBase, data processing, and Google Sheets, this workflow:\n\n1. **Discovers Investor Insights**: \n   - Automatically retrieves latest investor data\n   - Tracks key investment organizations\n   - Eliminates manual market research efforts\n\n2. **Intelligent Data Processing**:\n   - Filters investor-specific organizations\n   - Extracts critical investment metrics\n   - Ensures comprehensive market intelligence\n\n3. **Seamless Data Logging**:\n   - Automatically updates Google Sheets\n   - Creates real-time investor database\n   - Enables rapid market trend analysis\n\n4. **Scheduled Intelligence Gathering**:\n   - Daily automated tracking\n   - Consistent investor insight updates\n   - Zero manual intervention required\n\n## Key Benefits\n- 🤖 **Full Automation**: Zero-touch investor research\n- 💡 **Smart Filtering**: Targeted investment insights\n- 📊 **Comprehensive Tracking**: Detailed investor intelligence\n- 🌐 **Multi-Source Synchronization**: Seamless data flow\n\n## Workflow Architecture\n\n### 🔹 Stage 1: Investor Discovery\n- **Scheduled Trigger**: Daily market scanning\n- **CrunchBase API Integration**\n- **Intelligent Filtering**:\n  - Investor-specific organizations\n  - Key investment metrics\n  - Most recent data\n\n### 🔹 Stage 2: Data Extraction\n- **Comprehensive Metadata Parsing**\n- **Key Information Retrieval**\n- **Structured Data Preparation**\n\n### 🔹 Stage 3: Data Logging\n- **Google Sheets Integration**\n- **Automatic Row Appending**\n- **Real-Time Database Updates**\n\n## Potential Use Cases\n- **Venture Capitalists**: Investment ecosystem mapping\n- **Startup Scouts**: Investor trend analysis\n- **Market Researchers**: Comprehensive investment insights\n- **Business Development**: Strategic partnership identification\n- **Investment Analysts**: Market intelligence gathering\n\n## Setup Requirements\n1. **CrunchBase API**\n   - API credentials\n   - Configured access permissions\n   - Investor organization tracking setup\n\n2. **Google Sheets**\n   - Connected Google account\n   - Prepared tracking spreadsheet\n   - Appropriate sharing settings\n\n3. **n8n Installation**\n   - Cloud or self-hosted instance\n   - Workflow configuration\n   - API credential management\n\n## Future Enhancement Suggestions\n- 🤖 Advanced investment trend analysis\n- 📊 Multi-source investor aggregation\n- 🔔 Customizable alert mechanisms\n- 🌐 Expanded investment stage tracking\n- 🧠 Machine learning insights generation\n\n## Technical Considerations\n- Implement robust error handling\n- Use secure API authentication\n- Maintain flexible data processing\n- Ensure compliance with API usage guidelines\n\n## Ethical Guidelines\n- Respect business privacy\n- Use data for legitimate research\n- Maintain transparent information gathering\n- Provide proper attribution\n\n## Hashtag Performance Boost 🚀\n#InvestorIntelligence #VentureCapital #MarketResearch #AIWorkflow #DataAutomation #StartupEcosystem #InvestmentTracking #BusinessIntelligence #TechInnovation #StartupFunding\n\n## Workflow Visualization\n\n```plaintext\n[Daily Trigger]\n    ⬇️\n[Fetch Investor Data]\n    ⬇️\n[Extract Investor Fields]\n    ⬇️\n[Log to Google Sheets]\n```\n\n## Connect With Me\n\n**Ready to revolutionize your investor research?**\n\n📧 **Email**: Yaron@nofluff.online\n\n🎥 **YouTube**: [@YaronBeen](https://www.youtube.com/@YaronBeen/videos)\n\n💼 **LinkedIn**: [Yaron Been](https://www.linkedin.com/in/yaronbeen/)\n\n**Transform your market intelligence with intelligent, automated workflows!**",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "integration:httpRequest"],
+			"triggerType": "schedule",
+			"hasAI": false,
+			"score": 85.26,
+			"scoreBreakdown": {
+				"traction": 0.513,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4731",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 4849,
+			"slug": "automated-invoice-processing-with-telegram-gpt-4o-ocr-and-sa-4849",
+			"name": "Automated Invoice Processing with Telegram, GPT-4o, OCR and SAP Integration",
+			"description": "**++HOW IT WORKS:++**\nThis workflow automates the processing of invoices sent via Telegram. It extracts the data using LlamaIndex OCR, logs it in Google Sheets, and optionally pushes the structured data to SAP Business One\n\n****🔹 1. Receive Invoice via Telegram:****\n- A user sends a PDF of an invoice through Telegram\n- A Telegram Trigger node listens for incoming messages and captures the file and metadata\n- The document is downloaded and prepared for OCR\n\n**🔹 2. OCR with LlamaIndex:**\n- The file is uploaded to the LlamaIndex OCR API.\n- The workflow polls the API until the processing status returns SUCCESS\n- Once ready, the parsed content is fetched in Markdown format\n\n**🔹 3. Data Extraction via LLM (editable):**\n- The Markdown content is sent to a language model (LLM) using LangChain\n- A Structured Output Parser transforms the result into a clean, structured editable JSON\n\n**🔹 4. Save to Google Sheets:**\nThe structured JSON is split into:\n1. Header (main invoice metadata)\n1. Detail (individual line items)\n\nEach part is stored in a dedicated tab within a connected Google Sheets file\n\n**🔹 5. Ask for SAP Confirmation:**\nThe bot replies to the user via Telegram:\n\n\"Do you want to send the data to SAP?\"\n\nIf the user clicks \"Yes\", the next automation path is triggered.\n\n**🔹 6. Push Data to SAP B1:**\nA connection is made to SAP Business One's Service Layer API\n\nHeader and detail data are fetched from Google Sheets\n\nThe invoice structure is rebuilt as required by SAP (DocumentLines, CardCode, etc.)\n\nA POST request creates the Purchase Invoice in SAP\n\nA confirmation message with the created DocEntry is sent back to the user on Telegram\n\n**++SET UP STEPS:++**\nFollow these steps to properly configure the workflow before execution:\n\n**1️⃣ Create Required Credentials:**\nGo to Credentials &gt; + New Credential and create the following:\n- *Telegram API* (set your bot token get it from BotFather)\n- *Google Sheets*\n- *OpenAI*\n\n**2️⃣ Set Up Environment Variables (Optional but Recommended):**\nLLAMAINDEX_API_KEY\nSAP_USER\nSAP_PASSWORD\nSAP_COMPANY_DB\nSAP_URL\n\n**3️⃣ Prepare Google Sheets:**\nEnsure your Google Spreadsheet has the following:\n➤ Sheet 1: Header\n➤ Sheet 2: Details\nContains columns for invoice lines",
+			"nodes": [
+				"n8n-nodes-base.wait",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.noOp",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.outputParserStructured"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:httpRequest"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 85.21,
+			"scoreBreakdown": {
+				"traction": 0.631,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.519
+			},
+			"source": "https://n8n.io/workflows/4849",
+			"author": "raquelgiugliano",
+			"success": true
+		},
+		{
+			"id": 4596,
+			"slug": "qr-code-generator-via-webhook-4596",
+			"name": "QR Code Generator via Webhook",
+			"description": "This n8n template allows you to instantly generate QR codes from any text or URL by simply sending a webhook request. It's a versatile tool for creating dynamic QR codes for various purposes, from marketing campaigns to event registrations, directly integrated into your automated workflows.\n\n---\n\n# 🔧 How it works\n- Receive Data Webhook: This node acts as the entry point for the workflow. It listens for incoming POST requests and expects a JSON body with a data property containing the text or URL you want to encode into the QR code.\n- Generate QR Code: This node makes an HTTP GET request to the QR Server API (api.qrserver.com) to generate the QR code image. The content from your webhook is passed as the data parameter to the API.\n- Respond with QR Code: This node sends the response from the QR Server API back to the service that initiated the webhook. The QR Server API directly returns the image data, so your webhook response will be the QR code image itself.\n\n---\n\n# 👤 Who is it for?\n### This workflow is ideal for:\n\n- Marketers: Generate QR codes for product links, event registrations, or promotional materials on the fly.\n- Developers: Integrate QR code generation into applications, websites, or internal tools.\n- Event Organizers: Create dynamic QR codes for ticketing, information access, or check-ins.\n- Businesses: Streamline processes requiring physical-to-digital transitions, like menu access or contact sharing.\n- Automation Enthusiasts: Add QR code generation capabilities to any workflow.\n\n---\n\n# 📑 Data Structure\nWhen you trigger the webhook, send a POST request with a JSON body structured as follows:\n\n```\n{\n  \"data\": \"https://www.yourwebsite.com/your-specific-page-or-text-to-encode\"\n}\n```\n\nThe workflow will return the QR code image directly in the response.\n\n---\n\n# ⚙️ Setup Instructions\n- Import Workflow: In your n8n editor, click \"Import from JSON\" and paste the provided workflow JSON.\n- Configure Webhook Path:\n  - Double-click the Receive Data Webhook node.\n  - In the 'Path' field, set a unique and descriptive path (e.g., /generate-qr).\n- Customize QR Code (Optional):\n  - Double-click the Generate QR Code node.\n  - You can adjust the size parameter in the URL (e.g., size=200x200 for a larger QR code) or add other parameters supported by the QR Server API (e.g., bgcolor, color, qzone).\n- Activate Workflow: Save and activate the workflow.\n\n---\n\n# 📝 Tips\n- Handling the Image Output: Since the QR Server API directly returns the image, the webhook response will be the image data. Depending on your use case, you might want to:\n  - Save to File/Cloud: Insert a node (e.g., Write Binary File, Amazon S3, Google Drive) after Generate QR Code to save the image to a file system or cloud storage.\n  - Embed in HTML/Email: If you're building an HTML response or sending an email, you might need to convert the image data to a Base64 string or provide a URL to a saved image.\n- Error Handling: Enhance workflow robustness by adding an Error Trigger node. This allows you to catch any issues during QR code generation and set up notifications or logging.\n- Dynamic Size/Color: You can extend the Receive Data Webhook to accept parameters for size, color, or bgcolor in the incoming JSON. Then, dynamically pass these to the url of the Generate QR Code node to create highly customizable QR codes.\n- Input Validation: For more advanced use cases, you could add a Function node after the webhook to validate the incoming data to ensure it's in a valid format (e.g., a URL).",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.respondToWebhook"
+			],
+			"tags": ["trigger:webhook", "integration:httpRequest"],
+			"triggerType": "webhook",
+			"hasAI": false,
+			"score": 85.15,
+			"scoreBreakdown": {
+				"traction": 0.508,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4596",
+			"author": "ist00dent",
+			"success": true
+		},
+		{
+			"id": 4887,
+			"slug": "auto-create-podcast-from-youtube-transcript-using-dumpling-a-4887",
+			"name": "Auto-Create Podcast from YouTube Transcript using Dumpling AI and GPT-4o",
+			"description": "### 🔎 Who is this for?\nThis workflow is designed for podcast creators, content marketers, and video producers who want to convert YouTube videos into podcast-ready scripts. It's perfect for anyone repurposing long-form content to reach audio-first audiences without manual effort.\n\n---\n\n### 🧠 What problem is this workflow solving?\nCreating podcast scripts from YouTube videos manually is time-consuming. This workflow automates the process by pulling transcripts, cleaning the text, organizing the dialogue, summarizing the key points, and saving everything in one place. It removes the need for manual transcription, formatting, and structuring.\n\n---\n\n### ⚙️ What this workflow does\n\nThis workflow uses **Dumpling AI** and **GPT-4o** to automate the transformation of YouTube video transcripts into polished podcast scripts. Here's how it works:\n\n1. **RSS Feed Trigger**\n   - Monitors a YouTube RSS feed for new video uploads. When a new video is detected, the workflow begins automatically.\n\n2. **Get YouTube Transcript (Dumpling AI)**\n   - Uses Dumpling AI's `get-youtube-transcript` endpoint to extract the full transcript from the video URL.\n\n3. **Generate Podcast Script with GPT-4o**\n   - GPT-4o receives the transcript and generates a structured JSON output including:\n     - Cleaned transcript with filler words removed\n     - Speaker labels for clarity\n     - A short, engaging podcast title\n     - A concise summary of the episode\n\n4. **Save to Airtable**\n   - The structured data (title, summary, cleaned transcript) is saved to Airtable for easy review, editing, or publishing.\n\n---\n\nThis automation is an ideal workflow for repurposing video content into audio-friendly formats, cutting down production time while increasing content output across platforms.\n",
+			"nodes": [
+				"n8n-nodes-base.rssFeedReadTrigger",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.airtable",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:other", "ai", "integration:httpRequest"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 85.15,
+			"scoreBreakdown": {
+				"traction": 0.507,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/4887",
+			"author": "yang",
+			"success": true
+		},
+		{
+			"id": 5910,
+			"slug": "auto-generate-and-post-instagram-reels-with-veo3-openai-and--5910",
+			"name": "Auto-Generate and Post Instagram Reels with Veo3, OpenAI, and Blotato",
+			"description": "📱 Veo3 Instagram Agent – Create & Auto-Post Reels with Blotato\n\nDescription:\nThis no-code workflow automates the full pipeline of generating and publishing Instagram Reels using Veo3 (via Wavespeed API). From prompt to post, it handles content ideation, short-form video generation, caption writing, logging, and even automatic publishing to Instagram via Blotato.\n\nPerfect for creators, brands, and marketers who want to scale content creation without needing to shoot or edit videos manually.\n\n🔗  Watch the full step-by-step tutorial on how to build this workflow:\nhttps://youtu.be/s-KzxeKWmIA?si=6x8WKMeiyWodZWVq\n\nGoogle Sheet Template: https://docs.google.com/spreadsheets/d/1bA-PQTrvekC1Rti-XumGANgjIwLjvcFCqoIxVCYsq2E/edit?usp=sharing\n\n🚀 What This Workflow Does:\nTrigger via Chat or Telegram\n Start with a simple message like:\n \"Make a reel for a luxury minimalist candle brand using calm aesthetics.\"\n\nAI Video Prompt Generation\n Uses OpenAI to craft a visually rich, platform-optimized video description prompt.\n\n🎞️ Video Creation with Veo3 API\n Submits your prompt to Veo3 to create a short video (9:16 ratio, 8 seconds) with motion, tone, and trend styles.\n\n✍️ Caption Writing\n An AI agent writes an engaging and playful caption based on the video content.\n\n📄 Google Sheets Logging\n Stores prompt, video URL, caption, and status in a GSheet to keep track of all generated assets.\n\n📤 Auto-Publish to Instagram\n Posts the video + caption directly to Instagram using Blotato’s social media publishing API.\n\n🔌 Tools & Integrations Used:\nOpenAI for prompt & caption generation\n\nWavespeed API (Veo3) for video generation\n\nGoogle Sheets for tracking\n\nBlotato for scheduling & publishing content\n\nn8n for orchestration and automation logic\n\n💡 Use Cases:\nContent calendar automation for small teams\n\nTrend-based ad creation and testing\n\nUGC-style reel generation for e-commerce\n\nRapid ideation & creative experimentation",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:httpRequest"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 85.1,
+			"scoreBreakdown": {
+				"traction": 0.62,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.538
+			},
+			"source": "https://n8n.io/workflows/5910",
+			"author": "marconi",
+			"success": true
+		},
+		{
+			"id": 5271,
+			"slug": "learn-n8n-expressions-with-an-interactive-step-by-step-tutor-5271",
+			"name": "🎓 Learn n8n Expressions with an Interactive Step-by-Step Tutorial for Beginners",
+			"description": "## How it works\n\nThis template is an interactive, step-by-step tutorial designed to teach you the most important skill in n8n: **using expressions to access and manipulate data**.\n\nIf you know what JSON is but aren't sure how to pull a specific piece of information from one node and use it in another, this workflow is for you. It starts with a single \"Source Data\" node that acts as our filing cabinet, and then walks you through a series of lessons, each demonstrating a new technique for retrieving and transforming that data.\n\nYou will learn how to:\n1.  **Access a simple value** from a previous node.\n2.  Use n8n's built-in selectors like **`.last()`** and **`.first()`**.\n3.  Get a specific item from a list (**Array**).\n4.  Drill down into nested data (**Objects**).\n5.  Combine these techniques to access data in an **array of objects**.\n6.  Go beyond simple retrieval by using **JavaScript functions** to do math or change text.\n7.  Inspect data with utility functions like **`Object.keys()`** and **`JSON.stringify()`**.\n8.  Summarize data from **multiple items** using `.all()` and arrow functions.\n\n## Set up steps\n\n**Setup time: 0 minutes!**\n\nThis workflow is a self-contained tutorial and requires no setup or external credentials.\n\n1.  Click **\"Execute Workflow\"** to run the entire tutorial.\n2.  Follow the flow from the \"Source Data\" node to the \"Final Exam\" node.\n3.  For each lesson, click on the node to see how its expressions are configured in the parameters panel.\n4.  Read the detailed sticky note next to each lesson—it breaks down exactly how the expression works and why.\n\nBy the end, you'll have the foundational knowledge to connect data and build powerful, dynamic workflows in n8n.",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitOut"
+			],
+			"tags": ["trigger:manual", "integration:set"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 85.09,
+			"scoreBreakdown": {
+				"traction": 0.697,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.231
+			},
+			"source": "https://n8n.io/workflows/5271",
+			"author": "lucaspeyrin",
+			"success": true
+		},
+		{
+			"id": 10427,
+			"slug": "analyze-facebook-ads-send-insights-to-google-sheets-with-gem-10427",
+			"name": "Analyze Facebook Ads & Send Insights to Google Sheets with Gemini AI",
+			"description": "Stop manually digging through Meta Ads data and spending hours trying to connect the dots.\n\nThis workflow turns n8n into an AI-powered media buyer that automatically analyzes your ad performance, categorizes your creatives, and delivers insights directly into a Google Sheet.\n\n➡️ Watch the full 4-part setup and tutorial on YouTube:\nhttps://youtu.be/hxQshcD3e1Y\n\nAbout This 4-Part Automation Series\n\nAs a media buyer, I built this system to automate the heavy lifting of analyzing ad data and brainstorming new creative ideas.\nThis template is the first foundational part of that larger system.\n\n✅ Part 1 (This Template): Pulling Ad Data & Getting Quick Insights\nAutomatically pulls data into a Google Sheet and uses an LLM to categorize ad performance.\n\n✅ Part 2: Finding the Source Files for the Best Ads\nFetches the image or video files for top-performing ads.\n\n✅ Part 3: Using AI to Understand Why an Ad Works\nSends your best ads to Google Gemini for structured notes on hooks, transcripts, and visuals.\n\n✅ Part 4: Getting the AI to Suggest New Creative Ideas\nUses all the insights to generate fresh ad concepts, scripts, and creative briefs.\n\nWhat This Template (Part 1) Does\n\nSecure Token Management\nAutomatically retrieves and refreshes your Facebook long-term access token.\n\nFetch Ad Data\nPulls the last 28 days of ad-level performance data from your Facebook Ads account.\n\nProcess & Clean\nParses raw data, standardizes key e-commerce metrics (like ROAS), and filters for sales-focused campaigns.\n\nBenchmark Calculation\nAggregates all data to create an overall performance benchmark (e.g., average Cost Per Purchase).\n\nAI Analysis\nA “Senior Media Buyer” AI persona evaluates each ad against the benchmark and categorizes it as “HELL YES,” “YES,” or “MAYBE,” with justifications.\n\nOutput to Google Sheets\nUpdates your Google Sheet with both raw performance data and AI-generated insights.\n\nWho Is It For?\n\nE-commerce store owners\n\nDigital marketing agencies\n\nFacebook Ads media buyers\n\nHow to Set It Up\n\nCredentials\n\nConnect your Google Gemini and Google Sheets accounts in the respective nodes.\n\nThe template uses NocoDB for token management. Configure the “Getting Long-Term Token” and “Updating Token” nodes — or replace them with your preferred credential storage method.\n\nUpdate Your IDs\n\nIn the “Getting Data For the Past 28 Days…” HTTP Request node, replace act_XXXXXX in the URL with your Facebook Ad Account ID.\n\nIn both Google Sheets nodes (“Sending Raw Data…” and “Updating Ad Insights…”), update the Document ID with your target Google Sheet’s ID.\n\nRun the Workflow\n\nClick “Test workflow” to run your first AI-powered analysis!\n\nTools Used\n\nn8n\n\nFacebook for Developers\n\nGoogle AI Studio (Gemini)\n\nNocoDB (or any credential database of your choice)",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.nocoDb",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.sort",
+				"n8n-nodes-base.filter",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.aggregate"
+			],
+			"tags": ["trigger:manual", "ai", "integration:code"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 85.08,
+			"scoreBreakdown": {
+				"traction": 0.61,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.577
+			},
+			"source": "https://n8n.io/workflows/10427",
+			"author": "jj-tham",
+			"success": true
+		},
+		{
+			"id": 5396,
+			"slug": "ai-timesheet-generator-with-gmail-calendar-github-to-google--5396",
+			"name": "AI Timesheet Generator with Gmail, Calendar & GitHub to Google Sheets",
+			"description": "# AI-Powered Automatic Timesheet Generator for Google Sheets\n\nStop wasting billable hours on manual time-tracking. **AutoTimesheet Pro** uses AI to collect emails, meetings, and GitHub work, then writes a clean timesheet straight into Google Sheets. Perfect for developers, consultants, agencies, and remote teams.\n\n## Get Started with [n8n](https://n8n.partnerlinks.io/ds9podzjls6d) now!\n\n---\n\n## 🚀 Key Features\n\n- **Automated Google Sheets time-tracking** — zero spreadsheet prep.  \n- **AI-generated activity summaries** (≤ 120 chars) via OpenAI GPT-4o-mini.  \n- **Gmail integration** — logs only important emails, skipping newsletters & no-replies.  \n- **Google Calendar time logger** — captures confirmed events, duration, and attendees.  \n- **GitHub commit & PR tracker** — records your commits plus opened/closed PRs.  \n- **Daily 7 PM cron trigger** (easily adjustable).  \n- **Month-based sheet creation** — new tab spins up on the first run each month.  \n- **No-code n8n template** — just connect credentials and tweak one **Set Variables** node.\n- **🔌 Easily extensible** — drag-and-drop extra n8n nodes to add Slack, Jira, Notion, Asana, Trello, Toggl, or any other data source you need.\n\n---\n\n## 🔍 How It Works\n\n1. **Collect** — n8n pulls data from Gmail, Google Calendar, and chosen GitHub repos.  \n2. **Clean** — filters remove noise (newsletters, irrelevant commits, etc.).  \n3. **Condense** — OpenAI rewrites each item into a concise, SEO-friendly description.  \n4. **Write** — workflow appends *Date*, *Type*, and *Description* to your **Timesheet** Google Sheet.\n5. **Extend** — simply insert new n8n nodes (e.g., Slack, Notion, Jira) and merge them into the same pipeline.\n\n---\n\n## 📈 Benefits for SEO-Minded Professionals\n\n- **Keyword-rich activity log** improves internal search and reporting.  \n- **Structured data** in Sheets simplifies export to accounting or PM tools.  \n- **Consistent naming** (`CALENDAR_EVENT`, `EMAIL`, `COMMIT`, `PR`) makes analytics easy.\n\n---\n\n## ✅ Why Choose AutoTimesheet Pro?\n\n- Zero manual entry — just open the sheet and bill clients.  \n- Immediate visibility into where your hours went.  \n- Works with any GitHub repo list and any inbox you own.  \n- 100 % no-code setup — activate in minutes.\n- Built on n8n, so you can customize and scale without limits.\n---\n\n## 📥 Get Started\n\nReady to replace manual time-tracking with smart automation?  \n\n#### https://n8n.partnerlinks.io/ds9podzjls6d\n\nJoin **N8N** now, connect your Google & GitHub accounts, and let AI handle your daily log.\n\n---",
+			"nodes": [
+				"n8n-nodes-base.googleCalendar",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.github",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.aggregate",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.cron",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleSheets"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:aggregate"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 85.07,
+			"scoreBreakdown": {
+				"traction": 0.618,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.542
+			},
+			"source": "https://n8n.io/workflows/5396",
+			"author": "zivkovic58",
+			"success": true
+		},
+		{
+			"id": 13904,
+			"slug": "auto-create-instagram-carousel-posts-from-canva-with-openai--13904",
+			"name": "Auto-create Instagram carousel posts from Canva with OpenAI and Blotato",
+			"description": "# Auto-Create Instagram Carousel Posts from Canva (Webhook → AI Caption → Instagram)\n\nAutomatically turn Canva carousel exports into a fully published Instagram post with AI-generated captions.\nThis workflow receives a webhook payload containing PNG slides (for example from Claude Cowork or a Canva automation), uploads the images, generates an optimized Instagram caption using AI, and publishes the carousel post via Blotato.\nIt removes the manual work of downloading slides, writing captions, and posting to Instagram.\n\n## What this template does\nWhen triggered by a webhook, this workflow:\nReceives a payload containing carousel slide images\nSplits the slides into individual items\nUploads each image to a media host\nAggregates all images into a carousel\nUses AI to generate an Instagram caption with hashtags\nPublishes the post to Instagram via Blotato\nThis allows you to go from Canva design → Instagram post automatically.\n\n## Example use cases\nThis workflow is useful for:\nSocial media managers automating Instagram posting\nContent creators producing carousel posts at scale\nAgencies generating client posts automatically\nAI-assisted content pipelines\nMarketing automation systems\nExample automation pipeline:\nClaude → Canva → n8n → Instagram\n\nWorkflow overview\nWebhook → Split Slides → Upload Media → Aggregate Images → Generate Caption → Publish Instagram Post\nNode breakdown\nWebhook\nReceives a POST request containing the carousel slide data.\nThe payload includes slide metadata and PNG URLs generated by Canva.\nSplit Out Slides - Splits the slides array so each slide is processed individually.\nThis allows each PNG image to be uploaded and processed as its own item.\nUpload Media (Blotato) - Uploads each slide image to the media host used by the social publishing platform.\nAggregate collects all uploaded image URLs into a single list.\nMessage a Model (AI Caption Generator)\nTelegram Node for Approval\nCreate Post (Blotato) - Creates and publishes the Instagram carousel post\n\n## Requirements\nBefore using this template you must configure the following:\nOpenAI API credential\nBlotato API credential\nInstagram account connected to Blotato\nA system that sends the webhook (Claude, Canva, or another automation)\n\n## Setup instructions\nImport the workflow into n8n\nConfigure credentials:\nOpenAI\nBlotato\nCopy the webhook URL from the Webhook node\nConfigure your upstream tool (Claude / Canva / automation) to send slide data to this webhook\nTest the workflow by sending a sample payload\nActivate the workflow\nOnce active, new carousel payloads will automatically be turned into Instagram posts\n\n## Customization ideas\nYou can easily extend this workflow by:\nAdding Telegram approval before posting\nPosting to TikTok, LinkedIn, or Facebook\nStoring posts in Google Sheets or Notion\nGenerating captions in different tones or languages\nAdding AI analysis of the slides to generate smarter captions",
+			"nodes": [
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.splitOut",
+				"@blotato/n8n-nodes-blotato.blotato",
+				"n8n-nodes-base.aggregate",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.noOp",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:blotato"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 85.04,
+			"scoreBreakdown": {
+				"traction": 0.552,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.8
+			},
+			"source": "https://n8n.io/workflows/13904",
+			"author": "marconi",
+			"success": true
+		},
+		{
+			"id": 10174,
+			"slug": "ppc-campaign-intelligence-optimization-with-google-ads-sheet-10174",
+			"name": "PPC Campaign Intelligence & Optimization with Google Ads, Sheets & Slack",
+			"description": "## How it Works\n\nThis workflow automatically monitors your Google Ads campaigns every day, analyzing performance with AI-powered scoring to identify scaling opportunities and catch issues before they drain your budget. Each morning at 9 AM, it fetches all active campaign data including clicks, impressions, conversions, costs, and conversion rates from your Google Ads account.\n\nThe AI analysis engine evaluates four critical dimensions: CTR (click-through rate) to measure ad relevance, conversion rate to assess landing page effectiveness, cost per conversion to evaluate profitability, and traffic volume to identify scale-readiness. Each campaign receives a performance score (0-100 points) and is automatically categorized as Excellent (75+), Good (55-74), Fair (35-54), or Underperforming (0-34).\n\nHigh-performing campaigns trigger instant Slack alerts to your PPC team with detailed scaling recommendations and projected ROI improvements, while underperforming campaigns generate urgent alerts with specific optimization actions. Every campaign is logged to your Google Sheets dashboard with daily metrics, and the system generates personalized email reports—action-oriented scaling plans for top performers and troubleshooting guides for campaigns needing attention.\n\nThe entire analysis takes minutes, providing your team with daily intelligence reports that would otherwise require hours of manual spreadsheet work and data analysis.\n\n---\n\n## Who is this for?\n\n- PPC managers and paid media specialists drowning in campaign data and manual reporting\n- Marketing agencies managing multiple client accounts needing automated performance monitoring\n- E-commerce brands running high-spend campaigns who can't afford budget waste\n- Growth teams looking to scale winners faster and pause losers immediately\n- Anyone spending $5K+ monthly on Google Ads who needs data-driven optimization decisions\n\n---\n\n## Setup Steps\n\n- **Setup time:** Approx. 15-25 minutes (credential configuration, dashboard setup, alert customization)\n- **Requirements:**\n    - Google Ads account with active campaigns\n    - Google account with a tracking spreadsheet\n    - Slack workspace\n    - SMTP email provider (Gmail, SendGrid, etc.)\n\n- Create a Google Sheets dashboard with two tabs: \"Daily Performance\" and \"Campaign Log\" with appropriate column headers.\n- Set up these nodes:\n    - **Schedule Daily Check:** Pre-configured to run at 9 AM daily (adjust timing if needed).\n    - **Fetch Google Ads Data:** Connect your Google Ads account and authorize API access.\n    - **AI Performance Analysis:** Review scoring thresholds (CTR, conversion rate, cost benchmarks).\n    - **Route by Performance:** Automatically splits campaigns into high-performers vs. issues.\n    - **Update Campaign Dashboard:** Connect Google Sheets and select your \"Daily Performance\" tab.\n    - **Log All Campaigns:** Select your \"Campaign Log\" tab for historical tracking.\n    - **Slack Alerts:** Connect workspace and configure separate channels for scaling opportunities and performance issues.\n    - **Generate Action Plan:** Customize email templates with your brand voice and action items.\n    - **Email Performance Report:** Configure SMTP and set recipient email addresses.\n\n- Credentials must be entered into their respective nodes for successful execution.\n\n---\n\n## Customization Guidance\n\n- **Scoring Weights:** Adjust point values for CTR (30), conversion rate (35), cost efficiency (25), and volume (10) in the AI Performance Analysis node based on your business priorities.\n- **Performance Thresholds:** Modify the 75-point Excellent threshold and 55-point Good threshold to match your campaign quality distribution and industry benchmarks.\n- **Benchmark Values:** Update CTR benchmarks (5% excellent, 3% good, 1.5% average) and conversion rate targets (10%, 5%, 2%) for your industry.\n- **Alert Channels:** Create separate Slack channels for different alert types or route critical alerts to Microsoft Teams, Discord, or SMS via Twilio.\n- **Email Recipients:** Configure different recipient lists for scaling alerts (executives, growth team) vs. optimization alerts (campaign managers).\n- **Schedule Frequency:** Change from daily to hourly monitoring for high-spend campaigns, or weekly for smaller accounts.\n- **Additional Platforms:** Duplicate the workflow structure for Facebook Ads, Microsoft Ads, or LinkedIn Ads with platform-specific nodes.\n- **Budget Controls:** Add nodes to automatically pause campaigns exceeding cost thresholds or adjust bids based on performance scores.\n\n---\n\nOnce configured, this workflow will continuously monitor your ad spend, identify opportunities worth thousands in additional revenue, and alert you to issues before they waste your budget—transforming manual reporting into automated intelligence.\n\n---\n\n**Built by Daniel Shashko**  \n[Connect on LinkedIn](https://www.linkedin.com/in/daniel-shashko/)",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.googleAds",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.slack",
+				"n8n-nodes-base.emailSend",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "integration:code"],
+			"triggerType": "schedule",
+			"hasAI": false,
+			"score": 85.03,
+			"scoreBreakdown": {
+				"traction": 0.57,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.727
+			},
+			"source": "https://n8n.io/workflows/10174",
+			"author": "tomax",
+			"success": true
+		},
+		{
+			"id": 5149,
+			"slug": "create-pdf-from-html-with-gotenberg-5149",
+			"name": "🛠️ Create PDF from HTML with Gotenberg",
+			"description": "## How it works\n\nThis workflow converts an HTML string into a polished PDF file using the powerful open-source [Gotenberg](https://gotenberg.dev/) service. It's designed to be a reusable utility in your automation stack.\n\n1.  **Receives Input:** The workflow is triggered with a JSON object containing the full `html` code as a string and a desired `file_name` for the output.\n2.  **Prepares File:** It converts the incoming HTML string into a binary `index.html` file, which is required for the API call.\n3.  **Calls Gotenberg API:** It sends the HTML file to a running Gotenberg instance via an HTTP request. It also dynamically sets the output filename and embeds metadata (like Author, Title, and Creation Date) directly into the PDF.\n4.  **Returns PDF:** The workflow outputs the final binary PDF file, ready to be saved, sent in an email, or used in the next step of your main workflow.\n\n## Set up steps\n\n**Setup time: ~3 minutes**\n\nThis workflow has one critical prerequisite: a running Gotenberg instance that your n8n can connect to.\n\n**1. Prerequisite: Run Gotenberg**\n\nYou need to have the Gotenberg service running. The easiest way is with Docker. Add the following service to your `docker-compose.yml` file (the same one you use for n8n):\n\n```yaml\nservices:\n  # ... your n8n service ...\n\n  gotenberg:\n    image: gotenberg/gotenberg:8\n    restart: always\n```\n\nThen, restart your stack with `docker compose up -d`. This makes Gotenberg available at the address `http://gotenberg:3000` from within your n8n container.\n\n**2. Use as a Sub-Workflow**\n\nThis workflow is ready to be used as a sub-workflow.\n\n1.  In your main workflow, add an **Execute Sub-Workflow** node.\n2.  In the **Workflow** parameter, select this \"Create PDF from HTML\" workflow.\n3.  Provide the input data in the required format: a JSON object with `html` and `file_name` keys.",
+			"nodes": [
+				"n8n-nodes-base.convertToFile",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:other", "integration:convertToFile"],
+			"triggerType": "other",
+			"hasAI": false,
+			"score": 84.99,
+			"scoreBreakdown": {
+				"traction": 0.499,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5149",
+			"author": "lucaspeyrin",
+			"success": true
+		},
+		{
+			"id": 5218,
+			"slug": "find-the-cheapest-flights-automatically-with-bright-data-n8n-5218",
+			"name": "Find the Cheapest Flights Automatically with Bright Data & n8n",
+			"description": "# \n\n## Description\n\nThis workflow automatically searches multiple flight booking websites to find the cheapest flights for your desired routes. It leverages web scraping to compare prices across platforms, helping you save money on air travel.\n\n## Overview\n\nThis workflow automatically searches multiple flight booking websites to find the cheapest flights for your desired routes. It uses Bright Data to scrape flight prices and can notify you when prices drop below your target threshold.\n\n### Tools Used\n\n*   **n8n:** The automation platform that orchestrates the workflow.\n*   **Bright Data:** For scraping flight prices from booking websites.\n*   **Notification Services:** Email, SMS, or other messaging platforms.\n\n## How to Install\n\n1.  **Import the Workflow:** Download the `.json` file and import it into your n8n instance.\n2.  **Configure Bright Data:** Add your Bright Data credentials to the Bright Data node.\n3.  **Set Up Notifications:** Configure your preferred notification method.\n4.  **Customize:** Set your routes, date ranges, and price thresholds.\n\n## Use Cases\n\n*   **Frequent Travelers:** Find the best deals for your regular routes.\n*   **Travel Agencies:** Monitor flight prices for client bookings.\n*   **Budget Travelers:** Get notified when flights to your dream destination become affordable.\n\n---\n\n## Connect with Me\n\n*   **YouTube:** [https://www.youtube.com/@YaronBeen/videos](https://www.youtube.com/@YaronBeen/videos)\n*   **LinkedIn:** [https://www.linkedin.com/in/yaronbeen/](https://www.linkedin.com/in/yaronbeen/)\n*   **Get Bright Data:** [https://get.brightdata.com/1tndi4600b25](https://get.brightdata.com/1tndi4600b25) (Using this link supports my free workflows with a small commission)\n\n#n8n #automation #travel #flights #brightdata #dealalerts #webscraping #flightdeals #cheapflights #travelhacks #budgettravel #travelplanning #airfare #flightprices #travelautomation #n8nworkflow #workflow #nocode #traveltech #flightbooking #savemoney #traveltools #flightcomparison #bestflightdeals #travelsmarter #automatedtravel\n",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.html",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.httpRequest"
+			],
+			"tags": ["trigger:manual", "integration:html"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 84.98,
+			"scoreBreakdown": {
+				"traction": 0.499,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5218",
+			"author": "yaron-nofluff",
+			"success": true
+		},
+		{
+			"id": 3053,
+			"slug": "technical-stock-analysis-with-telegram-airtable-and-a-gpt-po-3053",
+			"name": "Technical stock analysis with Telegram, Airtable and a GPT-powered AI Agent",
+			"description": "### Video Guide\n\nI prepared a detailed guide that demonstrates the complete process of building a trading agent automation using n8n and Telegram, seamlessly integrating various functions for stock analysis.\n\n[![Youtube Thumbnail](https://res.cloudinary.com/de9jgixzm/image/upload/v1740845597/Youtube%20Thumbs/Video%2022%20-%20Philipp%20Trading%20Blur.png)](https://youtu.be/94vh6hSiP9s)\n\n[Youtube Link](https://youtu.be/94vh6hSiP9s)\n\n### Who is this for?\nThis workflow is perfect for traders, financial analysts, and developers looking to automate stock analysis interactions via Telegram. It’s especially valuable for those who want to leverage AI tools for technical analysis without needing to write complex code.\n\n### What problem does this workflow solve?\nMany traders desire real-time analysis of stock data but lack the technical expertise or tools to perform in-depth analysis. This workflow allows users to easily interact with an AI trading agent through Telegram for seamless stock analysis, chart generation, and technical evaluation, all while eliminating the need for manual interventions.\n\n### What this workflow does\nThis workflow utilizes n8n to construct an end-to-end automation process for stock analysis through Telegram communication. The setup involves:\n- Receiving messages via a Telegram bot.\n- Processing audio or text messages for trading queries.\n- Transcribing audio using OpenAI API for interpretation.\n- Gathering and displaying charts based on user-specified parameters.\n- Performing technical analysis on generated charts.\n- Sending back the analyzed results through Telegram.\n\n\n### Setup\n\n1. **Prepare Airtable**:\n    - Create simple table to store tickers.\n\n2. **Prepare Telegram Bot**:\n    - Ensure your Telegram bot is set up correctly and listening for new messages.\n\n3. **Replace Credentials**:\n    - Update all nodes with the correct credentials and API keys for services involved.\n\n4. **Configure API Endpoints**:\n    - Ensure chart service URLs are correctly set to interact with the corresponding APIs properly.\n\n5. **Start Interaction**:\n    - Message your bot to initiate analysis; specify ticker symbols and desired chart styles as required.",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.toolWorkflow",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.switch",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.airtableTool",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.airtable",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:langchain"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 84.96,
+			"scoreBreakdown": {
+				"traction": 0.581,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.667
+			},
+			"source": "https://n8n.io/workflows/3053",
+			"author": "lowcodingdev",
+			"success": true
+		},
+		{
+			"id": 4336,
+			"slug": "webhook-enabled-ai-pdf-analyzer-4336",
+			"name": "Webhook-enabled AI PDF analyzer",
+			"description": "## Who this template is for\n\nThis template is for researchers, students, professionals, or content creators who need to quickly extract and summarize key insights from PDF documents using AI-powered analysis.\n\n## Use case\n\nConverting lengthy PDF documents into structured, digestible summaries organized by topic with key insights. This is particularly useful for processing research papers, reports, whitepapers, or any document where you need to quickly understand the main topics and extract actionable insights without reading the entire document.\n\n## How this workflow works\n\n1. **Document Upload**: Receives PDF files through a POST endpoint at `/ai_pdf_summariser`\n2. **File Validation**: Checks that the PDF is under 10MB and has fewer than 20 pages to meet API limits\n3. **Content Extraction**: Extracts text content from the PDF file\n4. **AI Analysis**: Uses OpenAI's GPT-4o-mini to analyze the document and break it down into distinct topics\n5. **Insight Generation**: For each topic, generates 3 key insights with titles and detailed explanations\n6. **Format Response**: Converts the structured data into markdown format for easy reading\n7. **Return Results**: Provides the formatted summary along with document metadata (file hash)\n\n## Set up steps\n\n1. **Configure OpenAI API**: Set up your OpenAI credentials for the GPT-4o-mini model\n2. **Deploy Webhook**: The workflow automatically creates a POST endpoint at `/ai_pdf_summariser`\n3. **Test Upload**: Send a PDF file to the endpoint using a multipart/form-data request\n4. **Adjust Limits**: Modify the file size (10MB) and page count (20) validation limits if needed based on your requirements\n5. **Customize Prompts**: Update the system prompt in the Information Extractor node to change how topics and insights are generated\n\nThe workflow includes comprehensive error handling for file validation failures (400 error) and processing errors (500 error), ensuring reliable operation even with problematic documents.",
+			"nodes": [
+				"n8n-nodes-base.noOp",
+				"n8n-nodes-base.respondToWebhook",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.informationExtractor",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.crypto",
+				"n8n-nodes-base.webhook",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:respondToWebhook"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 84.94,
+			"scoreBreakdown": {
+				"traction": 0.539,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.833
+			},
+			"source": "https://n8n.io/workflows/4336",
+			"author": "n8n-team",
+			"success": true
+		},
+		{
+			"id": 3666,
+			"slug": "real-estate-lead-generation-with-batchdata-skip-tracing-crm--3666",
+			"name": "Real Estate Lead Generation with BatchData Skip Tracing & CRM Integration",
+			"description": "How It Works\n- \nThis workflow automates the entire property lead generation process in a few simple steps:\n\n1. Property Search: Connects to BatchData's Property Search API with customizable parameters (location, property type, value range, equity percentage, etc.)\n2. Lead Filtering & Scoring: Processes results to identify the most promising leads based on criteria like absentee ownership, years owned, equity percentage, and tax status. Each property receives a lead score to prioritize follow-up.\n3. Skip Tracing: Automatically retrieves owner contact information (phone, email, mailing address) for each qualified property.\n4. Data Formatting: Structures all property and owner data into a clean, organized format ready for your systems.\n5. Multi-Channel Output:\n- Generates an Excel spreadsheet with all lead details\n- Pushes leads directly to your CRM (configurable for HubSpot, Salesforce, etc.)\n- Sends a summary email with the spreadsheet attached\n\n\n\nThe workflow can run on a daily schedule or be triggered manually as needed. All parameters are easily configurable through dedicated nodes, requiring no coding knowledge.\n\nWho's It For\n-\nThis workflow is perfect for:\n\n- Real Estate Investors looking to find off-market properties with motivated sellers\n- Real Estate Agents who want to generate listing leads from distressed or high-equity properties\n- Investment Companies that need regular lead flow for acquisitions\n- Real Estate Marketers who run targeted campaigns to property owners\n- Wholesalers seeking to build a pipeline of potential deals\n- Property Service Providers (roof repair, renovation contractors, etc.) who target specific property types\n\nAnyone who needs reliable, consistent lead generation for real estate without the manual work of searching, filtering, and organizing property data will benefit from this automation.\n\nAbout BatchData\n-\nBatchData is a comprehensive property data provider that offers access to nationwide property information, owner details, and skip tracing services. Key features include:\n\n- Extensive Database: Covers 150+ million properties across all 50 states\n- Rich Property Data: Includes ownership information, tax records, sales history, valuation estimates, equity positions, and more\n- Skip Tracing Services: Provides owner contact information including phone numbers, email addresses, and mailing addresses\n- Distressed Property Indicators: Flags for pre-foreclosure, tax delinquency, vacancy, and other motivation factors\n- RESTful API: Professional API for programmatic access to all property data services\n- Regular Updates: Continuously refreshed data for accurate information\n\nBatchData's services are designed for real estate professionals who need reliable property and owner information to power their marketing and acquisition strategies. Their API-first approach makes it ideal for workflow automation tools like N8N.",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.spreadsheetFile",
+				"n8n-nodes-base.hubspot",
+				"n8n-nodes-base.emailSend",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.splitOut"
+			],
+			"tags": ["trigger:manual", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 84.92,
+			"scoreBreakdown": {
+				"traction": 0.538,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.833
+			},
+			"source": "https://n8n.io/workflows/3666",
+			"author": "zellerhaus",
+			"success": true
+		},
+		{
+			"id": 4485,
+			"slug": "telegram-ai-chatbot-agent-with-infranodus-graphrag-knowledge-4485",
+			"name": "Telegram AI Chatbot Agent with InfraNodus GraphRAG Knowledge Base",
+			"description": "## Using the knowledge graphs instead of RAG vector stores\n\nThis workflow creates a Telegram chatbot agent that has access to several knowledge bases at the same time (used as \"experts\"). \n\nThese knowledge bases are provided using the [InfraNodus GraphRAG](https://infranodus.com/use-case/ai-knowledge-graphs) using the knowledge graphs and providing high-quality responses without the need to set up complex RAG vector store workflows.\n\nThe advantages of using GraphRAG instead of the standard vector stores for knowledge are:\n\n- Easy and quick to set up and update (no complex data import workflows or vector stores needed)\n- A knowledge graph has a holistic view of your knowledge base and knows what it's about\n- Better retrieval of relations between the document chunks = higher quality responses\n\n![InfraNodus knowledge graph](https://support.noduslabs.com/hc/article_attachments/20266752795292)\n\n\n## How it works\nThis template uses the n8n AI agent node as an orchestrating agent that decides which tool (knowledge graph) to use based on the user's prompt. \n\nHere's a description step by step:\n\n- The user submits a question using the Telegram bot, which is then received in the n8n workflow via the Telegram trigger node.\n- The AI agent node checks a list of tools it has access to. Each tool has a description of the knowledge it has auto-generated by InfraNodus. \n- The AI agent decides which tool should be used to generate a response. It may reformulate user's query to be more suitable for the expert. \n- The query is then sent to the official InfraNodus Graph RAG Node or directly to the InfraNodus API via the HTTP node endpoint, which will query the graph that corresponds to that expert. \n- Each InfraNodus GraphRAG expert provides a rich response that takes the whole context into account and provides a response from each expert (graph) along with a list of relevant statements retrieved using a combination or RAG and GraphRAG. \n- The n8n AI Agent node integrates the responses received from the experts to produce the final answer.\n- The final answer is sent back to the Telegram bot who delivers it back to the private chat or a Telegram group.\n\n## How to use\n\nYou need an [InfraNodus GraphRAG API account and key](https://infranodus.com/use-case/ai-knowledge-graphs) to use this workflow. \n\n- Create an InfraNodus account\n- Get the API key at [https://infranodus.com/api-access](https://infranodus.com/api-access) and create a Bearer authorization key for the InfraNodus HTTP nodes.\n- Create a separate knowledge graph for each expert (using PDF / content import options) in InfraNodus\n- For each graph, go to the workflow, paste the name of the graph into the `body` `name` field.\n- Keep other settings intact or learn more about them at the [InfraNodus access points](https://support.noduslabs.com/hc/en-us/articles/13605983537692-InfraNodus-API-Access-Points) page. \n- Once you add one or more graphs as experts to your flow, add the LLM key to the OpenAI node\n- Create a Telegram bot (the instructions are in the workflow Post note) — it takes 30 seconds. Get its API key and create the Telegram credentials to use in the Telegram nodes in this workflow.\n\n## Requirements\n\n- An [InfraNodus](https://infranodus.com/use-case/ai-knowledge-graphs) account and API key\n- An OpenAI (or any other LLM) API key\n- A Telegram account\n\n\n## Customizing this workflow\n\nYou can use this same workflow with a standard AI chatbot via a URL that can also be embedded to any website. You can also use it with [ElevenLabs AI voice agent](https://support.noduslabs.com/hc/en-us/articles/20318967066396-How-to-Build-a-Text-Voice-AI-Agent-Chatbot-with-n8n-Elevenlabs-and-InfraNodus). There are many more customizations available. \n\nCheck out the **complete guide** at [https://support.noduslabs.com/hc/en-us/articles/20174217658396-Using-InfraNodus-Knowledge-Graphs-as-Experts-for-AI-Chatbot-Agents-in-n8n](https://support.noduslabs.com/hc/en-us/articles/20174217658396-Using-InfraNodus-Knowledge-Graphs-as-Experts-for-AI-Chatbot-Agents-in-n8n)\n\nAlso check out the **video tutorial** with a demo:\n\n[![Video tutorial](https://img.youtube.com/vi/kS0QTUvcH6E/sddefault.jpg)](https://www.youtube.com/watch?v=kS0QTUvcH6E)\n\n## Support\n\nIf you have any questions, contact us via the support portal at [https://support.noduslabs.com](https://support.noduslabs.com) or via our [Discord channel](https://discord.gg/v4BWAvTfB9).\n\nMore n8n workflows are available on our support portal: [n8n x InfraNodus AI automation workflows](https://support.noduslabs.com/hc/en-us/sections/18343587412252-AI-RAG-GraphRAG-and-LLM-Workflows).\n\n\n\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.telegram",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.httpRequestTool",
+				"n8n-nodes-infranodus.infranodusTool"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:httpRequestTool"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 84.92,
+			"scoreBreakdown": {
+				"traction": 0.6,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.583
+			},
+			"source": "https://n8n.io/workflows/4485",
+			"author": "infranodus",
+			"success": true
+		},
+		{
+			"id": 5926,
+			"slug": "get-a-summary-of-each-podcast-in-your-youtube-playlist-daily-5926",
+			"name": "Get a summary of each podcast in your YouTube playlist daily automatically free",
+			"description": "![youtube.png](fileId:2183)\n\n\n## Understand the workflow better.\n[watch this video](https://www.youtube.com/@ARRE-automation)\n## Good to know:\n\nThis workflow automatically transcribes your favorite podcasts or videos saved in a YouTube playlist and generates a comprehensive, AI-powered summary—so you can quickly understand the main topics and insights without having to watch or listen to the entire episode.\n\n## 👤 Who is this for?\n\nPodcast fans who want to save time and get the key points from episodes\n\nBusy professionals who follow educational or industry videos and need quick takeaways\n\nContent creators or researchers who organize and review large amounts of video/audio material\n\nAnyone who wants to efficiently capture and summarize information from YouTube playlists\n\n## ❓ What problem is this workflow solving?\n\nThis workflow solves the challenge of information overload from long-form podcasts and videos. It:\n\nAutomatically transcribes each video or podcast episode in your chosen YouTube playlist\n\nUses AI to create a clear, well-structured summary of the content\n\nLets you learn and extract valuable information without watching or listening to the entire recording\n\nOrganizes everything in a Google Sheets document for easy tracking and future reference\n\n## ✅ What this workflow does:\n\n📺 Fetches all videos from a specified YouTube playlist\n\n🔗 Extracts video titles, URLs, and IDs\n\n📝 Retrieves and combines transcripts for each video or podcast episode\n\n📜 Processes transcript data for clarity\n\n🤖 Uses AI to generate a detailed, sectioned summary that covers all main topics and insights\n\n📊 Automatically logs video titles, transcripts, summaries, and row numbers to a Google Sheets spreadsheet\n\n## ⚙️ How it works:\n\n🟢 Trigger: Start the workflow manually or on a schedule\n\n📺 Fetch videos from your chosen YouTube playlist\n\n🔗 Extract and organize video details (title, URL, ID)\n\n📝 Retrieve the transcript for each video or podcast episode\n\n📜 Combine transcript segments into a single script\n\n✂️ Extract the first sentences for focused summarization\n\n🤖 AI agent creates a comprehensive summary of the episode or video\n\n📊 Save all data—title, transcript, summary, and row number—to Google Sheets\n\n## 🛠️ How to use:\n\nSet up YouTube OAuth2 credentials in n8n\n\nConfigure Google Sheets OAuth2 credentials\n\nSet up API credentials for transcript and AI processing\n\nCreate and link your Google Sheets document\n\nInput your playlist ID and adjust any filters as needed\n\nActivate the workflow\n\n## 📝 Requirements:\n\nn8n instance (cloud or self-hosted)\nYouTube account with OAuth2 access\nGoogle Sheets account\nAccess to transcript and AI APIs\nBasic n8n workflow knowledge\n\n## 🟢 Customizing this workflow:\n\nChange the YouTube playlist ID to target your preferred podcasts or video series\n\nAdjust the transcript retrieval process for other APIs or formats\n\nCustomize the AI prompt for different summary styles or focus areas\n\nAdd or remove fields in the Google Sheets output\n\nChange the workflow trigger or polling frequency\n\nSwitch to a different AI model if desired\n\nThis workflow is designed to help you quickly learn from podcasts and videos you care about—without spending hours consuming the full content.\n",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.youTube",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleSheets",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.splitInBatches",
+				"@n8n/n8n-nodes-langchain.lmChatGroq",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.function",
+				"n8n-nodes-base.splitOut"
+			],
+			"tags": ["trigger:manual", "ai", "integration:code"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 84.82,
+			"scoreBreakdown": {
+				"traction": 0.533,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.833
+			},
+			"source": "https://n8n.io/workflows/5926",
+			"author": "arre",
+			"success": true
+		},
+		{
+			"id": 4151,
+			"slug": "ai-seo-readability-audit-check-website-friendliness-for-llms-4151",
+			"name": "AI SEO Readability Audit: Check Website Friendliness for LLMs",
+			"description": "## Who is this for?\nThis workflow is designed for SEO specialists, content creators, marketers, and website developers who want to ensure their web content is easily accessible, understandable, and indexable by Large Language Models (LLMs) like ChatGPT, Perplexity, and Google AI Overviews. If you're looking to optimize your site for the evolving AI-driven search landscape, this template is for you.\n\n## What problem is this workflow solving? / Use case\nModern AI tools often crawl websites without executing JavaScript. This can lead to them \"seeing\" a very different version of your page than a human user or traditional search engine bot might. This workflow helps you:\n- Identify how much of your content is visible without JavaScript.\n- Check for crucial on-page SEO elements that AI relies on (headings, meta descriptions, structured data).\n- Detect if your site presents JavaScript-blocking warnings.\n- Get an AI-generated readability score and actionable recommendations to improve AI-friendliness.\n\n## What this workflow does\n1.  **Receives a URL** via a chat interface.\n2.  **Sanitizes the input URL** to ensure it's correctly formatted.\n3.  **Fetches the website's HTML** content, simulating a non-JavaScript crawler (like Googlebot).\n4.  **Extracts key HTML features**: visible text length, presence of H1/H2/H3 tags, meta description, Open Graph data, structured data (JSON-LD), and `&lt;noscript&gt;` tags. It also checks for common JavaScript-blocking messages.\n5.  **Performs an AI SEO Analysis** using an LLM (via OpenAI) based on the extracted features.\n6.  **Provides a report** including an AI Readability Score (0-10), a summary, actionable recommendations, and a reminder to check the `robots.txt` file for AI bot access.\n\n## Setup\n- **Estimated setup time:** 2-5 minutes.\n1.  Import this workflow into your n8n instance.\n2.  Ensure you have an OpenAI account and API key.\n3.  Configure the \"OpenAI Chat Model\" node with your OpenAI API credentials. If you don't have credentials set up yet, create new ones in n8n.\n4.  Activate the workflow.\n5.  Interact with the chat interface provided by the \"When chat message received\" trigger node (you can access this via its webhook URL).\n\n## How to customize this workflow to your needs\n- **Change LLM Model:** In the \"OpenAI Chat Model\" node, you can select a different model that suits your needs or budget.\n- **Adjust AI Prompt:** Modify the prompt in the \"AI SEO Analysis\" node (Chain Llm) to change the focus of the analysis or the format of the report. For example, you could ask for more technical details or a different scoring system.\n- **User-Agent:** The \"Get HTML from Website\" node uses a Googlebot User-Agent. You can change this to simulate other bots if needed.\n- **JS Block Indicators:** The \"Extract HTML Features\" node contains a list of common JavaScript-blocking phrases. You can expand this list with other languages or specific messages relevant to your checks.",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:code"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 84.69,
+			"scoreBreakdown": {
+				"traction": 0.526,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.833
+			},
+			"source": "https://n8n.io/workflows/4151",
+			"author": "leonardvanhemert",
+			"success": true
+		},
+		{
+			"id": 4949,
+			"slug": "automate-whatsapp-booking-system-with-gpt-4-assistant-cal-co-4949",
+			"name": "Automate WhatsApp Booking System with GPT-4 Assistant, Cal.com and SMS Reminders",
+			"description": "\n![Workflow Screenshot](https://www.dr-firas.com/Automate-WhatsApp.png)\n\n# AI-powered WhatsApp booking system with instant SMS confirmations\n\n### Who is this for?\n\nThis workflow is designed for solo entrepreneurs, consultants, coaches, clinics, or any business that handles client appointments and wants to automate the entire scheduling experience via WhatsApp — without the need for live agents.\n\n### What problem is this workflow solving?\n\nResponding to inbound messages, collecting booking details, suggesting available times, and sending reminders can be a huge time drain. This workflow eliminates manual handling by:\n- Automating WhatsApp conversations with an AI assistant\n- Booking appointments directly into Cal.com\n- Sending timely SMS reminders before appointments\n\nIt ensures you never miss a lead or a follow-up — even while you sleep.\n\n### What this workflow does\n\nFrom a single WhatsApp message, the workflow:\n\n1. Triggers via a WhatsApp webhook\n2. Uses GPT-4 to handle conversation flow and qualify the prospect\n3. Collects name, email, selected service\n4. Calls Cal.com API to fetch available time slots\n5. Books the appointment and stores it in Google Sheets\n6. Sends a confirmation message via WhatsApp\n7. Periodically scans for upcoming appointments\n8. Sends SMS reminders to clients 2 hours before their session\n\n### Setup\n\n1. Connect your **Webhook** node to a WhatsApp API (e.g., 360dialog, Twilio, or Ultramsg)\n2. Add your **OpenAI API key** for the GPT-4 nodes\n3. Configure your **Cal.com API key** and set your calendar ID\n4. Link your **Google Sheets** with fields like: `name`, `email`, `date`, `time`, `status`, `reminder_sent`\n5. Connect your **SMS service** (e.g., sms77) with API credentials\n6. Adjust the schedule in the reminder node as needed\n\n### How to customize this workflow to your needs\n\n- **Change the language or tone of the AI assistant** by editing the system prompt in the GPT node\n- **Filter available time slots** by service, team member, or duration\n- **Modify the reminder timing** (e.g., 1 hour before, 24h before, etc.)\n- **Add conditional logic** to route users to different booking flows based on their responses\n- **Integrate additional CRMs** or notification channels like email or Slack\n\n📄 **Documentation**: [Notion Guide](https://automatisation.notion.site/WhatsApp-II-20f3d6550fd980b9b2e6fe5e1a84051b?source=copy_link)\n\n---\n\n### Need help customizing?\nContact me for consulting and support : [Linkedin](https://www.linkedin.com/in/dr-firas/) / [Youtube](https:/https://www.youtube.com/@DRFIRASS)",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.switch",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.googleSheetsTool",
+				"@n8n/n8n-nodes-langchain.toolHttpRequest",
+				"n8n-nodes-base.respondToWebhook",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.sms77"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:langchain"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 84.68,
+			"scoreBreakdown": {
+				"traction": 0.586,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.591
+			},
+			"source": "https://n8n.io/workflows/4949",
+			"author": "drfiras",
+			"success": true
+		},
+		{
+			"id": 5680,
+			"slug": "rag-chatbot-with-supabase-togetherai-openrouter-5680",
+			"name": "RAG Chatbot with Supabase + TogetherAI + Openrouter",
+			"description": "## ⚠️ RUN the FIRST WORKFLOW ONLY ONCE \n(as it will convert your content in Embedding format and save it in DB and is ready for the RAG Chat)\n\n## 📌 Telegram Trigger\n\n* **Type:** `telegramTrigger`\n* **Purpose:** Waits for new Telegram messages to trigger the workflow.\n* **Note:** Currently disabled.\n\n---\n\n## 📄 Content for the Training\n\n* **Type:** `googleDocs`\n* **Purpose:** Fetches document content from Google Docs using its URL.\n* **Details:** Uses Service Account authentication.\n\n---\n\n## ✂️ Splitting into Chunks\n\n* **Type:** `code`\n* **Purpose:** Splits the fetched document text into smaller chunks (1000 chars each) for processing.\n* **Logic:** Loops over text and slices it.\n\n---\n\n## 🧠 Embedding Uploaded Document\n\n* **Type:** `httpRequest`\n* **Purpose:** Calls Together AI embedding API to get vector embeddings for each text chunk.\n* **Details:** Sends JSON with model name and chunk as input.\n\n---\n\n## 🛢 Save the embedding in DB\n\n* **Type:** `supabase`\n* **Purpose:** Saves each text chunk and its embedding vector into the Supabase `embed` table.\n\n\n## SECOND WORKFLOW EXPLAINATION:\n\n## 💬 When chat message received\n\n* **Type:** `chatTrigger`\n* **Purpose:** Starts the workflow when a user sends a chat message.\n* **Details:** Sends an initial greeting message to the user.\n\n---\n\n## 🧩 Embend User Message\n\n* **Type:** `httpRequest`\n* **Purpose:** Generates embedding for the user’s input message.\n* **Details:** Calls Together AI embeddings API.\n\n---\n\n## 🔍 Search Embeddings\n\n* **Type:** `httpRequest`\n* **Purpose:** Searches Supabase DB for the top 5 most similar text chunks based on the generated embedding.\n* **Details:** Calls Supabase RPC function `matchembeddings1`.\n\n---\n\n## 📦 Aggregate\n\n* **Type:** `aggregate`\n* **Purpose:** Combines all retrieved text chunks into a single aggregated context for the LLM.\n\n---\n\n## 🧠 Basic LLM Chain\n\n* **Type:** `chainLlm`\n* **Purpose:** Passes the user's question + aggregated context to the LLM to generate a detailed answer.\n* **Details:** Contains prompt instructing the LLM to answer only based on context.\n\n---\n\n## 🤖 OpenRouter Chat Model\n\n* **Type:** `lmChatOpenRouter`\n* **Purpose:** Provides the actual AI language model that processes the prompt.\n* **Details:** Uses `qwen/qwen3-8b:free` model via OpenRouter and you can use any of your choice.",
+			"nodes": [
+				"n8n-nodes-base.googleDocs",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.supabase",
+				"n8n-nodes-base.telegramTrigger",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-base.aggregate",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"@n8n/n8n-nodes-langchain.lmChatOpenRouter",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:telegram", "ai", "integration:httpRequest"],
+			"triggerType": "telegram",
+			"hasAI": true,
+			"score": 84.65,
+			"scoreBreakdown": {
+				"traction": 0.528,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.818
+			},
+			"source": "https://n8n.io/workflows/5680",
+			"author": "iamvaar",
+			"success": true
+		},
+		{
+			"id": 4881,
+			"slug": "turn-google-sheets-ideas-into-ai-videos-with-gpt-4o-and-fal--4881",
+			"name": "Turn Google Sheets Ideas into AI Videos with GPT-4o and Fal.AI Veo 3",
+			"description": "\n**Turn Your Ideas into Videos—Right from Google Sheets!**\n\nThis workflow helps you make cool 8-second videos using Fal.AI and Veo 3, just by typing your idea into a Google Sheet. You can even choose if you want your video to have sound or not. It’s super easy—no tech skills needed!\n\n**Why use this?**\n\nJust type your idea in a sheet—*no fancy tools or uploads.*\n\nGet a video link back in the same sheet.\n\nWorks with or without sound—*your choice!*\n\n**How does it work?**\n\nYou write your idea, pick the video shape, and say if you want sound (true or false) in the Google Sheet.\n\nn8n reads your idea and asks Fal.AI to make your video.\n\nWhen your video is ready, the link shows up in your sheet.\n\n**What do you need?**\n\n- A Google account and Google Sheets connected with service account ([check this link for reference](https://docs.n8n.io/integrations/builtin/credentials/google/))\n- A copy of the following Google Spreadsheet:\n[Spreadsheet to copy](https://docs.google.com/spreadsheets/d/100ur8DnU_q2YIAx15ccMfEWC43Di_G7hj19csjxg73A/edit?usp=sharing)\n\n- An OpenAI API key\n\n- A Fal.AI account with some money in it\n\n**That’s it!** Just add your ideas and let the workflow make the videos for you. Have fun creating!\n\nIf you have any questions, just contact me in X **[@maxrojasdelgado](https://x.com/maxrojasdelgado)**.",
+			"nodes": [
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.httpRequest",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleSheetsTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.googleSheets"
+			],
+			"tags": ["trigger:other", "ai", "integration:httpRequest"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 84.62,
+			"scoreBreakdown": {
+				"traction": 0.537,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.778
+			},
+			"source": "https://n8n.io/workflows/4881",
+			"author": "maxr",
+			"success": true
+		},
+		{
+			"id": 3414,
+			"slug": "slack-ai-chatbot-for-business-team-with-rag-claude-3-7-sonne-3414",
+			"name": "Slack AI Chatbot for business team with RAG, Claude 3.7 Sonnet and Google Drive",
+			"description": "Imagine having an **AI chatbot on Slack** that seamlessly integrates with your company’s workflow, **automating repetitive requests**. No more digging through emails or documents to find answers about IT requests, company policies, or vacation days—just ask the bot, and it will instantly provide the right information.  \n\nWith its **24/7 availability**, the chatbot ensures that team members get immediate support without waiting for a colleague to be online, making assistance faster and more efficient.  \n\nMoreover, this AI-powered bot serves as a **central hub for internal communication**, allowing everyone to quickly access procedures, documents, and company knowledge without searching manually. A simple Slack message is all it takes to get the information you need, enhancing productivity and collaboration across teams.\n\n-----\n\n#### **How It Works**  \n1. **Slack Trigger**: The workflow starts when a user mentions the AI bot in a Slack channel. The trigger captures the message and forwards it to the AI Agent.  \n2. **AI Agent Processing**:  \n   - The AI Agent, powered by Anthropic's Claude 3.7 Sonnet model, processes the query.  \n   - It uses **Retrieval-Augmented Generation (RAG)** to fetch relevant information from the company’s internal knowledge base stored in Qdrant (a vector database).  \n   - A **Simple Memory** buffer retains recent conversation context (last 10 messages) for continuity.  \n3. **Knowledge Retrieval**:  \n   - The RAG tool searches Qdrant’s vector store using OpenAI embeddings to find the most relevant document chunks (top 10 matches).  \n4. **Response Generation**:  \n   - The AI synthesizes the retrieved data into a concise, structured response (1-2 sentences for the answer, 2-3 supporting details, and a source citation).  \n   - The response is formatted in Slack-friendly markdown (bullet points, blockquotes) and sent back to the user.  \n\n---  \n\n#### **Set Up Steps**  \n1. **Prepare Qdrant Vector Database**:  \n   - Create a Qdrant collection via HTTP request (`Create collection` node).  \n   - Optionally, refresh/clear the collection (`Refresh collection` node) before adding new documents.  \n2. **Load Company Documents**:  \n   - Fetch files from a Google Drive folder (`Get folder` → `Download Files`).  \n   - Process documents: Split text into chunks (`Token Splitter`) and generate embeddings (`Embeddings OpenAI2`).  \n   - Store embeddings in Qdrant (`Qdrant Vector Store1`).  \n3. **Configure Slack Bot**:  \n   - Create a Slack bot via Slack API with required permissions\n   - Add the bot to the desired Slack channel and note the `channelId` for the workflow.  \n4. **Deploy AI Components**:  \n   - Connect the AI Agent to Anthropic’s model, RAG tool, and memory buffer.  \n   - Ensure OpenAI embeddings are configured for both RAG and document processing.  \n5. **Test & Activate**:  \n   - Use the manual trigger (`When clicking ‘Test workflow’`) to validate document ingestion.  \n   - Activate the workflow to enable real-time Slack interactions.  \n\n----\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/).",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.vectorStoreQdrant",
+				"@n8n/n8n-nodes-langchain.toolCalculator",
+				"n8n-nodes-base.slackTrigger",
+				"n8n-nodes-base.slack",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterTokenSplitter",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.lmChatAnthropic"
+			],
+			"tags": ["trigger:other", "ai", "integration:langchain"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 84.56,
+			"scoreBreakdown": {
+				"traction": 0.537,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.765
+			},
+			"source": "https://n8n.io/workflows/3414",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 4977,
+			"slug": "organize-email-attachments-from-gmail-to-structured-google-d-4977",
+			"name": "Organize Email Attachments from Gmail to Structured Google Drive Folders",
+			"description": "# Automated Binary Data Extraction from Gmail to Google Drive Folder\n\n\nThis workflow is designed to automate the process of handling emails with binary attachments. It triggers when a new email arrives in a specified Gmail account (or can be configured with a similar email trigger) and is set to download any binary attachments. The workflow then filters the email to confirm it contains binary data (attachments). If attachments are present, it proceeds to retrieve the full email details, including all binary data.\n\nA crucial step is the creation of a new Google Drive folder. This folder is dynamically named using the email's subject and the current timestamp, for example, \"[Email Subject] - [Current Timestamp]\". Following this, the workflow separates each individual attachment from the email. Finally, these attachments are uploaded into the newly created Google Drive folder, with their original filenames preserved. The overall purpose of this workflow is to automatically organize and store email attachments into a structured Google Drive folder system. This workflow is compatible with any type of binary data found in an email, as the filter is designed to detect any binary data, not just PDFs.\n\n\n**How It Works**\n\n1. **Trigger:** The workflow initiates when a new email arrives in a specified Gmail account. Alternatively, it can be configured with a similar email trigger.\n\n2. **Download Attachments:** The workflow is set to automatically download any binary attachments from the incoming email.\n\n3. **Filter Attachments:** The workflow then filters the email to confirm it contains binary data (attachments).\n\n4. **Retrieve Full Email Details:** If attachments are present, the workflow proceeds to retrieve the complete details of the email, including all binary data.\n\n5. **Create Google Drive Folder:** A new folder is created in Google Drive. This folder is dynamically named using the email's subject and the current timestamp (e.g., \"[Email Subject] - [Current Timestamp]\").\n\n6. **Split Out Attachments:** Each individual binary attachment from the email is separated into its own item within the workflow.\n\n7. **Upload to Google Drive:** Finally, these separated attachments are uploaded into the newly created Google Drive folder, retaining their original filenames.\n\n\n**Need Help? Have Questions?**\nFor consulting and support, or if you have questions, please feel free to connect with me on [LinkedIn ](https://www.linkedin.com/in/michael-gullo-46b3b7274/) or email [michael.gullo@outlook.com](michael.gullo@outlook.com). \n",
+			"nodes": [
+				"n8n-nodes-base.gmailTrigger",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.splitOut"
+			],
+			"tags": ["trigger:gmail", "integration:googleDrive"],
+			"triggerType": "gmail",
+			"hasAI": false,
+			"score": 84.53,
+			"scoreBreakdown": {
+				"traction": 0.512,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.857
+			},
+			"source": "https://n8n.io/workflows/4977",
+			"author": "mgullo",
+			"success": true
+		},
+		{
+			"id": 4404,
+			"slug": "one-way-sync-between-telegram-notion-google-drive-and-google-4404",
+			"name": "One-way sync between Telegram, Notion, Google Drive, and Google Sheets",
+			"description": "# One-way sync between Telegram, Notion, Google Drive, and Google Sheets\n\n## Who is this for?\n\nThis workflow is perfect for productivity-focused teams, remote workers, virtual assistants, and digital knowledge managers who receive documents, images, or notes through Telegram and want to automatically organize and store them in Notion, Google Drive, and Google Sheets—without any manual work.\n\n## What problem is this workflow solving?\n\nManaging Telegram messages and media manually across different tools like Notion, Drive, and Sheets can be tedious. This workflow automates the classification and storage of incoming Telegram content, whether it’s a text note, an image, or a document. It saves time, reduces human error, and ensures that media is stored in the right place with metadata tracking.\n\n## What this workflow does\n\n- **Triggers on a new Telegram message** using the Telegram Trigger node.\n- **Classifies the message type** using a Switch node:\n  - Text messages are appended to a Notion block.\n  - Images are converted to base64, uploaded to imgbb, and then added to Notion as toggle-image blocks.\n  - Documents are downloaded, uploaded to Google Drive, and the metadata is logged in Google Sheets.\n- **Sends a completion confirmation** back to the original Telegram chat.\n\n## Setup\n\n1. **Telegram Bot**: Set up a bot and get the API token.\n2. **Notion Integration**:\n   - Share access to your target Notion page/block.\n   - Use the Notion API credentials and block ID where content should be appended.\n3. **Google Drive & Sheets**:\n   - Connect the relevant accounts.\n   - Select the destination folder and spreadsheet.\n4. **imgbb API**: Obtain a free API key from [imgbb](https://api.imgbb.com/).\n\nReplace placeholder credential IDs and asset URLs as needed in the imported workflow.\n\n## How to customize this workflow to your needs\n\n- **Change Storage Locations**:\n  - Update the Notion block ID or Google Drive folder ID.\n  - Switch Google Sheet to log in a different file or sheet.\n- **Add More Filters**:\n  - Use additional Switch rules to handle other Telegram message types (like videos or voice messages).\n- **Modify Response Message**:\n  - Personalize the Telegram confirmation text based on the file type or sender.\n- **Use a different image hosting service** if you don’t want to use imgbb.\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.telegramTrigger",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.notion",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.googleSheets"
+			],
+			"tags": ["trigger:telegram", "integration:telegram"],
+			"triggerType": "telegram",
+			"hasAI": false,
+			"score": 84.5,
+			"scoreBreakdown": {
+				"traction": 0.543,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.727
+			},
+			"source": "https://n8n.io/workflows/4404",
+			"author": "lakshit1996",
+			"success": true
+		},
+		{
+			"id": 3277,
+			"slug": "smart-email-auto-responder-template-using-ai-3277",
+			"name": "Smart Email Auto-Responder Template using AI",
+			"description": "# Smart Email Auto-Responder with AI Classification  \n## Automatically Categorize and Reply to Emails using LangChain + Google Gemini + Gmail + SMTP + Brevo\n \nThis n8n workflow is designed to intelligently manage incoming emails and automatically send personalized responses based on the content. It classifies emails using LangChain's Text Classifier, sends HTML responses depending on the category, and updates Gmail and Brevo CRM accordingly.\n\n---\n\n## Key Features  \n\n**Triggers and Classifies Emails**  \n- Listens for new Gmail messages every hour  \n- Uses AI-based classification to identify the type of inquiry For Example:  \n  - Guest Post  \n  - YouTube Review  \n  - Udemy Course Inquiry\n\n**Responds Automatically**  \n- Sends professional HTML replies customized for each type  \n- Uses SMTP to deliver emails from your domain  \n\n**Enhances Workflow with Automation**  \n- Marks processed emails as read  \n- Applies Gmail labels  \n- Adds sender to Brevo contact list  \n\n**Optional AI Chat Integration**  \n- Uses Google Gemini (PaLM 2) to enhance classification or summarization  \n\n---\n\n## Tools & Integrations Required  \n\n1. Gmail account (OAuth2)\n2. LangChain (Text Classifier node)\n3. Google Gemini API account\n4. SMTP credentials (e.g., Gmail SMTP, Brevo, etc.)\n5. Brevo/Sendinblue account and API key\n\n---\n\n## Step-by-Step Node Guide  \n\n### 1. Gmail Trigger  \nPolls Gmail every hour for new emails.  \nFilters out internal addresses (e.g., `@syncbricks.com`).  \nAvoids replying to already-responded emails (`Re:` subject filter).\n\n### 2. LangChain Text Classifier  \nUses AI to categorize the content of the email based on pre-defined categories:  \n- **Guest Post**  \n- **Youtube**  \n- **Udemy Courses**\n\n### 3. Google Gemini (PaLM) Chat Model *(Optional)*  \nProvides additional AI support to enhance classification accuracy.  \nCan be used to summarize or enrich the context if needed.\n\n### 4. Email Send Nodes  \nEach response category has a separate SMTP node with a custom HTML email:\n- **Guest Post Inquiry**  \n- **YouTube Video Inquiry**  \n- **Udemy Course Inquiry**\n\n### 5. Gmail: Mark as Read  \nMarks the email so it isn’t processed again.\n\n### 6. Gmail: Apply Label  \nAdds a label (e.g., `Handled by Bot`) for organization.\n\n### 7. Brevo: Create/Update Contact  \nSaves the sender to your CRM for future communication or marketing.\n\n---\n\n## Email Templates Included\n\n### Guest Post Template  \nIncludes pricing, website list, submission guidelines, and payment instructions.\n\n### YouTube Review Template  \nIncludes package pricing, review samples, video thumbnails, and inquiry instructions.  \n  \n### [Step by Step Tutorial](https://youtu.be/OAu6tOwubgE)\n\n### [GET n8n Now](https://www.udemy.com/course/mastering-n8n-ai-agents-api-automation-webhooks-no-code/?referralCode=0309FD70BE2D72630C09)  \n\n### [N8N COURSE](https://www.udemy.com/course/mastering-n8n-ai-agents-api-automation-webhooks-no-code/?referralCode=0309FD70BE2D72630C09)  \n### [n8n Book](https://lms.syncbricks.com/books/n8n/)  \n \n \n\nMore courses:  \n[http://lms.syncbricks.com](http://lms.syncbricks.com)\n\nYouTube Channel:  \n[https://youtube.com/@syncbricks](https://youtube.com/@syncbricks)\n\n---\n\n## How to Use\n\n1. Import the template into your n8n instance.\n2. Configure your Gmail OAuth2 and SMTP credentials.\n3. Set up your LangChain Text Classifier and Google Gemini API credentials.\n4. Update label ID in the Gmail node and ensure all custom fields like `from.value[0].name` match your use case.\n5. Run the workflow and watch it respond intelligently to new inquiries.\n\n---\n\n## Best Practices\n\n- Always test with mock emails first.\n- Keep the Google Gemini node optional if you want to reduce cost/API calls.\n- Use Gmail filters to auto-label certain types of emails.\n- Monitor your Brevo contacts to track new leads.\n\n---\n\n## Attribution & Support\n\n**Developed by Amjid Ali**  \nThis template took extensive time and effort to build. If you find it useful, please consider supporting my work.\n\n**Buy My Book:**  \n[Mastering n8n on Amazon](https://www.amazon.com/dp/B0F23GYCFW)\n\n**Full Courses & Tutorials:**  \n[http://lms.syncbricks.com](http://lms.syncbricks.com)\n\n**Follow Me Online:**  \nLinkedIn: [https://linkedin.com/in/amjidali](https://linkedin.com/in/amjidali)  \nWebsite: [https://amjidali.com](https://amjidali.com)  \nYouTube: [https://youtube.com/@syncbricks](https://youtube.com/@syncbricks)  \n",
+			"nodes": [
+				"n8n-nodes-base.gmailTrigger",
+				"@n8n/n8n-nodes-langchain.textClassifier",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"n8n-nodes-base.emailSend",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.sendInBlue",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:emailSend"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 84.44,
+			"scoreBreakdown": {
+				"traction": 0.563,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.636
+			},
+			"source": "https://n8n.io/workflows/3277",
+			"author": "amjid",
+			"success": true
+		},
+		{
+			"id": 14020,
+			"slug": "build-an-ai-confidence-coach-for-women-with-gpt-4o-google-sh-14020",
+			"name": "Build an AI confidence coach for women with GPT-4o, Google Sheets and Gmail",
+			"description": "## 📊 Description\nMost career advice is generic. This workflow builds a fully personalized AI coaching system that remembers every user, adapts to their career stage and goals, detects what kind of help they need, and gets more contextual with every conversation. It is not a simple chatbot — it is a structured coaching engine with user profiling, conversation memory, intent routing, and proactive weekly outreach.\nBuilt for women's communities, coaching platforms, HR teams, and edtech creators who want to deliver real personalized career support at scale without hiring a team of coaches.\n\n## What This Workflow Does\n💬 Opens a chat interface where users can start talking immediately — no signup required\n🧮 Detects if the user is new or returning on every message using Google Sheets as a user database\n📋 Walks new users through a 4-step onboarding — name, career stage, biggest challenge, and monthly goal\n🗂️ Stores and updates every user profile in Google Sheets with full onboarding state tracking\n🔍 Detects intent from every coaching message across 6 categories — salary negotiation, interview prep, career change, leadership, confidence building, and work-life balance\n🤖 Routes each message to a topic-specific GPT-4o system prompt tailored to that coaching category\n💬 Loads the last 5 conversations from history to give GPT-4o full context before generating a response\n✅ Responds with personalized advice, one actionable step for today, and a follow-up question to keep momentum\n📝 Logs every conversation to Google Sheets with timestamp, message, intent, and AI response\n📧 Sends every fully onboarded user a personalized weekly check-in email every Sunday with a weekly challenge, progress acknowledgment, and motivational quote from a woman leader\n\n## Key Benefits\n✅ Full conversation memory — every session builds on the last\n✅ Intent detection across 6 coaching categories — not one generic prompt\n✅ User profiling — advice is always tailored to their stage, challenge, and goal\n✅ Proactive weekly outreach — not just reactive coaching\n✅ Complete audit trail — every conversation logged to Google Sheets\n✅ Works for any number of users simultaneously via session-based identification\n✅ No login or signup needed — just open the chat URL and start\n\n## How It Works\n\nSW1 — Onboarding Every message hits the Chat Trigger and gets routed through the onboarding engine. The workflow reads all users from Google Sheets and matches the current session ID. If the user is new they go through 4 onboarding steps one message at a time — name, career stage with a numbered menu, biggest challenge with a numbered menu, and their monthly goal in their own words. Numbered responses are automatically mapped to their full label so 2 becomes Early Career (1-3 years) and 5 becomes Work-life balance. Every step is saved and the onboarding state is tracked so users can return to the same conversation and pick up exactly where they left off.\n\nSW2 — Coaching Engine Once onboarding is complete every subsequent message goes straight to the coaching engine. The workflow reads the user's last 5 conversations from the Conversation Log sheet for context. It then scans the message for intent keywords across 6 categories and selects the matching system prompt. GPT-4o receives the full user profile, conversation history, and topic-specific coaching instructions before generating a response. Every response includes a main coaching answer, one specific action the user can take today, and a follow-up question to continue the conversation. The full exchange is logged to the Conversation Log sheet.\n\nSW3 — Weekly Check-in Every Sunday at 10AM the workflow reads all fully onboarded users, pulls their recent conversation topics from the log, and generates a personalized weekly check-in email for each one via GPT-4o. The email includes a warm personalized greeting, acknowledgment of their progress, a concrete weekly challenge tied to their goal, and a motivational quote from a real woman leader relevant to their situation. Emails are sent via Gmail and every send is logged to the Weekly Checkins sheet.\n\n## Features\n- n8n Chat Trigger with public URL — shareable with any user\n- Session-based user identification — no login required\n- 4-step guided onboarding with numbered menu options\n- Numbered response to label mapping for clean data storage\n- New vs returning user detection on every message\n- Google Sheets as full user database and conversation memory\n- 6-category intent detection engine with keyword matching\n- Topic-specific GPT-4o system prompts per coaching category\n- Last 5 message context window passed to every GPT call\n- Structured JSON responses — advice, action step, follow-up question\n- Weekly Sunday proactive check-in via Gmail\n- Personalized HTML email with challenge box and quote section\n- Full logging across 3 sheets — User Profiles, Conversation Log, Weekly Checkins\n\n## Requirements\n- OpenAI API key (GPT-4o access)\n- Google Sheets OAuth2 connection\n- Gmail OAuth2 connection\n- A configured Google Sheet with 3 sheets as above\n\n## Setup Steps\n- Create a Google Sheet called \"AI Confidence Coach\" with 3 sheets — User Profiles, Conversation Log, Weekly Checkins\n- Paste your Sheet ID into all Google Sheets nodes\n- Add your Google Sheets OAuth2 credentials\n- Add your OpenAI API key\n- Add your Gmail OAuth2 credentials\n- Add your email as fallback in the Send Weekly Checkin Email node\n- Activate the workflow and copy the Chat \n- Trigger URL\n- Open the chat URL and test the full onboarding flow with 5 messages\n- Send a coaching question and confirm GPT-4o responds with personalized advice\n- Add your email to the User Profiles sheet and run SW3 manually to test the weekly check-in email\n- Share the chat URL with your users — the workflow runs itself from here\n\n## Target Audience\n🤖 Women's communities and career platforms who want to offer AI coaching at scale\n💼 HR teams building internal confidence and career development tools\n🎓 Edtech creators running women's upskilling and mentorship programs\n🔧 Automation agencies building AI coaching products for clients\n",
+			"nodes": [
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.gmail",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-base.if",
+				"@n8n/n8n-nodes-langchain.chat",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:googleSheets"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 84.41,
+			"scoreBreakdown": {
+				"traction": 0.623,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.391
+			},
+			"source": "https://n8n.io/workflows/14020",
+			"author": "rahul08",
+			"success": true
+		},
+		{
+			"id": 5368,
+			"slug": "manage-google-calendar-via-whatsapp-with-gpt-4-virtual-assis-5368",
+			"name": "Manage Google Calendar via WhatsApp with GPT-4 Virtual Assistant",
+			"description": "How it works\n• Allows users to manage their Google Calendar via WhatsApp using natural language\n• Handles event creation, updates, deletions, availability checks, and agenda overviews\n• AI agent interprets the user’s message and triggers the appropriate calendar action\n• Responses are sent back to the user via WhatsApp, with confirmation or schedule info\n\nSet up steps\n• Set up a WhatsApp Business Cloud account and configure your webhook\n• Connect your Google Calendar using n8n credentials\n• Deploy OpenAI API key for natural language understanding\n• Link each calendar action (create, update, delete, search) to the TimePilot agent\n• Customize confirmation messages and automate reply formatting\n\nNote: More detailed configuration and custom logic are described inside sticky notes within the workflow.",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.googleCalendarTool",
+				"n8n-nodes-base.whatsAppTrigger",
+				"n8n-nodes-base.whatsApp",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.agent",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:other", "ai", "integration:googleCalendarTool"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 84.41,
+			"scoreBreakdown": {
+				"traction": 0.545,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.7
+			},
+			"source": "https://n8n.io/workflows/5368",
+			"author": "floyd",
+			"success": true
+		},
+		{
+			"id": 11532,
+			"slug": "automated-ai-voice-cloning-from-youtube-videos-to-elevenlabs-11532",
+			"name": "Automated AI Voice Cloning 🤖🎤 from YouTube videos to ElevenLabs & Google Sheets",
+			"description": "This workflow automates the process of **creating cloned voices** in **ElevenLabs** using audio extracted from **YouTube** videos. It processes a list of video URLs from Google Sheets, converts them to audio, submits them to [ElevenLabs for voice cloning](https://try.elevenlabs.io/ahkbf00hocnu)*, and records the generated voice IDs back to the spreadsheet.\n\n*ONLY FOR STARTER, CREATOR, PRO PLAN\n\n\n\n**Important Considerations for Best Results:**\n\nFor optimal voice cloning quality with ElevenLabs, carefully select your source YouTube videos:\n- **Duration**: Choose videos that are sufficiently long (preferably 1-5 minutes of clear speech) to provide enough audio data for accurate voice modeling.\n- **Audio Quality**: Select videos with high-quality audio, minimal background noise, and clear vocal recording.\n- **Single Speaker**: Use videos featuring only **one primary speaker**. Multiple voices in the same audio will confuse the cloning algorithm and produce poor results.\n- **Consistent Voice**: Ensure the speaker maintains a consistent tone and speaking style throughout the clip for the most faithful reproduction.\n\n---\n\n\n### **Key Features**\n\n#### **1. ✅ Fully Automated Voice Creation Workflow**\n\n* No manual downloading, converting, or uploading is required.\n* Just paste the YouTube link and voice name into the sheet—everything else happens automatically.\n\n#### **2. ✅ Seamless Audio Extraction**\n\nUsing RapidAPI ensures:\n\n* High success rate in extracting audio\n* Support for virtually any YouTube video\n* Consistent output format required by ElevenLabs\n\n#### **3. ✅  Hands-Off ElevenLabs Voice Creation**\n\nThe workflow handles all the steps required by the ElevenLabs API, including:\n\n* Uploading binary audio\n* Naming voices\n* Capturing and storing the resulting voice ID\n\nThis is much faster than the manual method inside the ElevenLabs dashboard.\n\n#### **4. ✅ Centralized, Reusable Setup**\n\nOnce the API keys are added:\n\n* The same workflow can be reused indefinitely\n* Users don’t need technical skills\n* Updating only requires editing the sheet\n\n---\n\n### **How it works:**\n\n1. **Data Retrieval**: The workflow starts by fetching data from a Google Sheets spreadsheet that contains YouTube video URLs in the \"YOUTUBE VIDEO\" column and desired voice names in the \"VOICE NAME\" column. It specifically targets rows where the \"ELEVENLABS VOICE ID\" field is empty, ensuring only unprocessed videos are handled.\n\n2. **Video Processing Pipeline**:\n   - **Video ID Extraction**: Each YouTube URL is parsed to extract the unique video identifier using a regular expression.\n   - **Audio Conversion**: The video ID is sent to the RapidAPI \"YouTube MP3 2025\" service, which converts the YouTube video to an audio file (M4A format).\n   - **Audio Download**: The resulting audio file is downloaded locally for processing.\n\n3. **Voice Creation**: The downloaded audio file is submitted to ElevenLabs API via a POST request to the `/v1/voices/add` endpoint. This creates a new voice clone based on the audio sample. The voice name is currently hardcoded as \"Teresa Mannino\" in the workflow but should be dynamically configured to use the value from the \"VOICE NAME\" spreadsheet column.\n\n4. **Data Update**: The workflow captures the `voice_id` returned by ElevenLabs and writes it back to the corresponding row in the Google Sheets spreadsheet in the \"ELEVENLABS VOICE ID\" column, completing the processing cycle for that video.\n\n---\n\n### **Set up steps:**\n\n1. **Prepare the Data Sheet**: Duplicate the provided Google Sheets template. Fill in the \"YOUTUBE VIDEO\" column with YouTube URLs and the \"VOICE NAME\" column with your desired names for the cloned voices. Ensure your videos meet the quality criteria mentioned above.\n\n2. **Configure APIs**:\n   - **RapidAPI**: Sign up for a free trial API key from the \"YouTube MP3 2025\" service on RapidAPI. Enter this key into the `x-rapidapi-key` header field in the \"From video to audio\" node.\n   - **ElevenLabs**: Generate an API key from your ElevenLabs account. Configure the \"Create voice\" node's HTTP Header Authentication with the name `xi-api-key` and your ElevenLabs API key as the value.\n\n3. **Optional Customization**: Modify the \"Create voice\" node to use the dynamic voice name from your spreadsheet instead of the hardcoded \"Teresa Mannino\" value for more flexible operation.\n\n4. **Execute**: Run the workflow. It will automatically process each qualifying row, create voices in ElevenLabs, and populate the spreadsheet with the new Voice IDs. Monitor the workflow execution to ensure successful processing of each video.\n\n---\n\n👉 [Subscribe to my new **YouTube channel**](https://youtube.com/@n3witalia). Here I’ll share videos and Shorts with practical tutorials and **FREE templates for n8n**.\n\n[![image](https://n3wstorage.b-cdn.net/n3witalia/youtube-n8n-cover.jpg)](https://youtube.com/@n3witalia)\n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/). ",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:manual", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 84.35,
+			"scoreBreakdown": {
+				"traction": 0.561,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.625
+			},
+			"source": "https://n8n.io/workflows/11532",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 13353,
+			"slug": "ingest-and-enrich-q-a-pairs-then-store-in-data-table-1-2-13353",
+			"name": "Ingest and enrich Q&A pairs then store in Data Table [1/2]",
+			"description": "This workflow serves an n8n Form to end user to capture a Question and Answer pair (to be used by an Q&A AI Agent in a separate workflow).\n\nThe workflow:\n- Appends a `isTrusted` field depending on email domain\n- Adds AI-generated tags relevant to the Question and Answer pair\n- Stores the Q&A pair in an n8n Data Table \n\nThis template is part of the official n8n quick start tutorial (2026). [Watch it here](https://www.youtube.com/watch?v=GuaKeDS6UKU).\n",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.noOp",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.dataTable",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:set"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 84.32,
+			"scoreBreakdown": {
+				"traction": 0.497,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.875
+			},
+			"source": "https://n8n.io/workflows/13353",
+			"author": "max-n8n",
+			"success": true
+		},
+		{
+			"id": 4334,
+			"slug": "tradingview-signal-extractor-with-gmail-google-sheets-telegr-4334",
+			"name": "TradingView Signal Extractor with Gmail, Google Sheets & Telegram Notifications",
+			"description": "Stay ahead in your **trading game** with this powerful **n8n automation** workflow. Designed for real-time efficiency, this setup continuously **scans your Gmail inbox** for trading alerts from **TradingView** and ensures **you never miss a signal.**\n\nEvery minute, this workflow will:\n\n📩 **Check Gmail** for new messages using a trigger.\n🔍 **Identify** emails coming specifically from TradingView.\n📊 **Extract** key trading signals like **BUY** or **SELL** along with the company name.\n🕒 **Capture** the exact date and time of the alert.\n📄 **Log** all extracted signals neatly into a **Google Sheet** for easy tracking and analysis.\n📲 **Instantly notify you on Telegram** with a custom message so you can act fast.\n\nPerfect for **traders** who want an **automated assistant** to handle **alerts, record them for analysis,** and provide timely updates — **all without lifting a finger.**",
+			"nodes": [
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.dateTime",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.gmailTrigger"
+			],
+			"tags": ["trigger:gmail", "integration:code"],
+			"triggerType": "gmail",
+			"hasAI": false,
+			"score": 84.22,
+			"scoreBreakdown": {
+				"traction": 0.536,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.7
+			},
+			"source": "https://n8n.io/workflows/4334",
+			"author": "itechdp",
+			"success": true
+		},
+		{
+			"id": 4105,
+			"slug": "generate-invoices-save-to-drive-and-send-email-to-customer-w-4105",
+			"name": "Generate Invoices, Save to Drive and Send Email to Customer with JS + G Sheets",
+			"description": "This workflow automates invoice generation from form submissions, ensuring unique order IDs, creating PDF invoices, storing files, emailing customers, and logging invoice data — all seamlessly integrated.\n\n---\n\n## 🔹 Workflow Overview\n\n1. **Trigger (Webhook)**\n   Starts when an order form is submitted, capturing customer and order details.\n\n2. **Generate Random Order ID**\n   A Function node creates a unique alphanumeric invoice ID (e.g., `INV-X92B7D`).\n\n3. **Check for Duplicate Order ID**\n   Google Sheets looks up the generated order ID in your invoice log sheet to prevent duplicates.\n\n4. **Conditional Check (IF Node)**\n\n   * If the ID already exists → regenerates a new ID (loops back)\n   * If unique → proceeds to invoice creation\n\n5. **Prepare Invoice Data**\n   A Set node formats customer info, date, order items, and the unique order ID to fit your invoice template.\n\n6. **Convert HTML to PDF**\n   HTTP Request node sends your invoice HTML to the RapidAPI HTML-to-PDF service and receives the PDF file.\n\n7. **Upload PDF to Cloud Storage**\n   Save the PDF in Google Drive or Dropbox with a clear file name like `Invoice-INV-X92B7D.pdf`.\n\n8. **Send Invoice Email to Customer**\n   Email node attaches the PDF and includes the order ID in the email subject/body.\n\n9. **Log Invoice Details**\n   Append invoice data (customer info, order ID, total, PDF link) to your Google Sheet for tracking.\n\n---\n\n## ⚙️ Node Details & Setup\n\n### 1. Webhook Trigger\n\n* Configure to receive form submissions (order details like name, email, items, total).\n\n### 2. Function: Generate Random Order ID\n\n* Sample JS code generates unique IDs prefixed by `INV-`.\n\n### 3. Google Sheets: Lookup Row\n\n* Set up connection to your invoice log sheet.\n* Search for existing order ID to avoid duplicates.\n\n### 4. IF Node: Check Order ID Existence\n\n* Condition: If order ID found → loop to regenerate.\n* Else → continue workflow.\n\n### 5. Set Node: Prepare Invoice HTML\n\n* Define variables like customer name, date, items, and order ID.\n* This data populates your HTML invoice template.\n\n### 6. HTTP Request: Convert HTML to PDF\n\n* [API URL to get your key](https://rapidapi.com/rhodium/api/html2pdf2/playground/apiendpoint_9b1017c6-2f56-4b7e-80d5-0fe24937d398)\n* Send invoice HTML in the request body.\n* Receive PDF file blob or download URL.\n\n### 7. Google Drive (or Dropbox) Upload\n\n* Upload the PDF file.\n* Use file name format: `Invoice-{{$json[\"order_id\"]}}.pdf`\n\n### 8. Email Node\n\n* Recipient: customer email from the form data.\n* Attach generated PDF.\n* Include order ID in email subject or body for reference.\n\n### 9. Google Sheets: Append Row\n\n* Log invoice metadata to keep records updated.\n\n---\n\n## 📁 Google Sheets Template\n\nYou can make a copy of the invoice log template [here](https://docs.google.com/spreadsheets/d/1QW_Lg1aoEBku8GaxwPbZfBY5ITAuSdvoAXRyNdCEujM/edit?gid=0)\n\n`This sheet includes columns for order\\_id, customer name, email, total, and invoice PDF link. Customize it as needed.`\n\n---\n\n## 📌 Additional Notes\n\n* Customize the invoice HTML template inside the Set node to match your branding.\n* Ensure API credentials for RapidAPI, Google Drive/Dropbox, and email are properly set up in your n8n credentials.\n* You can expand this workflow by adding payment processing or SMS notifications.\n\n---\n\n## Need help or want a custom workflow?\n\nReach out via email at [joseph@uppfy.com](mailto:joseph@uppfy.com).",
+			"nodes": [
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.emailSend",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:webhook", "integration:code"],
+			"triggerType": "webhook",
+			"hasAI": false,
+			"score": 84.18,
+			"scoreBreakdown": {
+				"traction": 0.527,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.727
+			},
+			"source": "https://n8n.io/workflows/4105",
+			"author": "mjomba",
+			"success": true
+		},
+		{
+			"id": 3446,
+			"slug": "daily-newsletter-service-using-excel-outlook-and-ai-3446",
+			"name": "Daily Newsletter Service using Excel, Outlook and AI",
+			"description": "### This n8n template builds a newsletter (\"daily digest\") delivery service which pulls and summarises the latest n8n.io template in select categories defined by subscribers.\n\nIt's scheduled to run once a day and sends the newsletter directly to subscriber via a nicely formatted email. If you've had trouble keeping up with the latest and greatest templates beign published daily, this workflow can save you a lot of time!\n\n### How it works\n* A scheduled trigger pulls a list of subscribers (email and category preferences) from an Excel workbook.\n* We work out unique categories amongst all subscribers and only fetch the latest n8n website templates from these categories to save on resources and optimise the number of API calls we make.\n* The fetched templates are summarised via AI to produce a short description which is more suitable for our email format.\n* For each subscriber, we filter and collect only the templates relevant to their category preferences (as defined in the Excel) and ensure that duplicate templates or those which have been \"seen before\" are omitted.\n* A HTML node is then used to generate the email newsletter. HTML emails are the perfect format since we can add links back to the template.\n* Finally, we use the Outlook node to send the email digest to the subscriber.\n\n### How to use\n* Populate your Excel sheet with 3 columns: name, email and categories. Categories is a comma-delimited list of categories which match the n8n template website. The available categories are AI, SecOps, Sales, IT Ops, Marketing, Engineering, DevOps, Building Blocks, Design, Finance, HR, Other, Product and Support.\n* To subscribe a new user, simply add their email to the Excel sheet with at least one category.\n* To unsubscribe a user, remove them from the sheet.\n* If you're not interested in paid templates, you may want to filter them out after fetching.\n\n### Requirements\n* Microsoft Excel for subscriber list\n* Microsoft Outlook for delivering emails\n* OpenAI for AI-generated descriptions\n\n### Customising the workflow\n* Use AI to summarise the week's trend of templates types and use-cases\n* This template can be the basis for other similar newsletters - just pull in a list of things from anywhere!",
+			"nodes": [
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.microsoftExcel",
+				"n8n-nodes-base.set",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"n8n-nodes-base.aggregate",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.splitInBatches",
+				"@n8n/n8n-nodes-langchain.chainLlm",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.noOp",
+				"n8n-nodes-base.removeDuplicates",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.html",
+				"n8n-nodes-base.microsoftOutlook",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:schedule", "ai", "integration:set"],
+			"triggerType": "schedule",
+			"hasAI": true,
+			"score": 84.15,
+			"scoreBreakdown": {
+				"traction": 0.557,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.6
+			},
+			"source": "https://n8n.io/workflows/3446",
+			"author": "jimleuk",
+			"success": true
+		},
+		{
+			"id": 3796,
+			"slug": "auto-generate-meeting-attendee-research-with-gpt-4o-google-c-3796",
+			"name": "Auto-Generate Meeting Attendee Research with GPT-4o, Google Calendar, and Gmail",
+			"description": "### How it works:\n\nWhenever a new event is scheduled on your Google Calendar, this workflow generates a Meeting Briefing email, giving an overview of each person on the call and the company they work for.\n\nIt makes use of the [web search](https://platform.openai.com/docs/guides/tools-web-search?api-mode=responses) tool on the OpenAI Responses API to make lookups.\n\nThe workflow triggers when a new event is added to the calendar, loops over each attendee, generating reports on each person and their company, collates the results, and sends the briefing as an email.\n\n### Set up steps:\n\n- Add your credentials for Google Calendar (for viewing events) and Gmail (to send the email)\n- Add your OpenAI credentials as a Header Auth on the Company Search and Person Search nodes.\n\t- Name: Authorization\n\t- Value: Bearer {{ YOUR_API_KEY }}\n- Edit the \"Edit Fields\" node with the email that you want to send the briefing to, and a short bit of context about yourself.",
+			"nodes": [
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleCalendarTrigger",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.aggregate",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.markdown",
+				"n8n-nodes-base.gmail"
+			],
+			"tags": ["trigger:other", "integration:set"],
+			"triggerType": "other",
+			"hasAI": false,
+			"score": 84.14,
+			"scoreBreakdown": {
+				"traction": 0.529,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.714
+			},
+			"source": "https://n8n.io/workflows/3796",
+			"author": "adamjanes",
+			"success": true
+		},
+		{
+			"id": 11205,
+			"slug": "generate-marketing-ad-banners-with-line-gemini-and-nano-bana-11205",
+			"name": "Generate Marketing Ad Banners with LINE, Gemini, and Nano Banana Pro",
+			"description": "## About This Template\nThis workflow creates high-quality, text-rich advertising banners from simple LINE messages. \n\nIt combines **Google Gemini** (for marketing-focused prompt engineering) and **Nano Banana Pro** (accessed via Kie.ai API) to generate images with superior text rendering capabilities. It also handles the asynchronous API polling required for high-quality image generation.\n\n## How It Works\n1.  **Input:** Users send a banner concept via LINE (e.g., \"Coffee brand, morning vibe\").\n2.  **Prompt Engineering:** Gemini optimizes the request into a detailed prompt, specifying lighting, composition, and Japanese catch-copy placement.\n3.  **Async Generation:** The workflow submits a job to Nano Banana Pro (Kie API) and intelligently waits/polls until the image is ready.\n4.  **Hosting:** The final image is downloaded and uploaded to a public AWS S3 bucket.\n5.  **Delivery:** The image is pushed back to the user on LINE.\n\n## Who It’s For\n* Marketing teams creating A/B test assets.\n* Japanese market advertisers needing accurate text rendering.\n* Developers looking for an example of **Async API Polling** patterns in n8n.\n\n## Requirements\n* **n8n** (Cloud or Self-hosted).\n* **Kie.ai API Key** (for Nano Banana Pro model).\n* **Google Gemini API Key**.\n* **AWS S3 Bucket** (Public access enabled).\n* **LINE Official Account** (Messaging API).\n\n## Setup Steps\n1.  **Credentials:** Configure the \"Header Auth\" credential for the Kie.ai nodes (Header: `Authorization`, Value: `Bearer YOUR_API_KEY`).\n2.  **AWS:** Ensure your S3 bucket allows public read access so LINE can display the image.\n3.  **Webhook:** Add the production webhook URL to your LINE Developers console.",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.webhook",
+				"n8n-nodes-base.code",
+				"@n8n/n8n-nodes-langchain.googleGemini",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.awsS3"
+			],
+			"tags": ["trigger:webhook", "ai", "integration:httpRequest"],
+			"triggerType": "webhook",
+			"hasAI": true,
+			"score": 84.01,
+			"scoreBreakdown": {
+				"traction": 0.575,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.5
+			},
+			"source": "https://n8n.io/workflows/11205",
+			"author": "pippi",
+			"success": true
+		},
+		{
+			"id": 3772,
+			"slug": "automatically-classify-and-label-gmail-emails-with-google-ge-3772",
+			"name": "Automatically Classify and Label Gmail Emails with Google Gemini AI",
+			"description": "### Description\nQuickly organize your inbox with AI!\nThis simple workflow automatically classifies incoming emails into different categories — like High Priority, Work Related, or Promotions — and applies Gmail labels accordingly.\nSetup takes less than 2 minutes, and it runs 24/7, helping you stay focused on what matters most without manual sorting.\n\n### Tools/Services Needed\n* Gmail: To trigger the workflow and label emails.\n* Google Gemini (or any LLM Model): To intelligently classify email content.\n\n\n### How It Works\n1. Gmail Trigger: Detects every new incoming email.\n\n\n2. Text Classifier Node: Classifies the email content into predefined categories.\n\n\n3. Google Gemini Chat Model: Provides the AI-powered understanding behind the classification.\n4. Conditional Labeling:\n- If the email is High Priority, label it accordingly.\n- If it’s Work Related (e.g., internal emails), apply the work label.\n- If it’s a Promotion, sort it into the promotions label.\n5. Gmail Labeling: Automatically adds the correct label to the email.\n\n### Setup Instructions\n* Connect your Gmail account to n8n.\n* Connect your Google Gemini (or other LLM) credentials.\n* Customize the categories and labels if needed.\n* Activate the workflow — and that's it!\n\n### Notes\n* You can easily add more categories (like \"Finance,\" \"Newsletters,\" etc.) by adjusting the classification prompt.\n* Works best with a clean and minimal set of categories to avoid overlap.\n* Can be adapted to work with any other large language model (OpenAI, Claude, etc.) if preferred.",
+			"nodes": [
+				"n8n-nodes-base.gmailTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatGroq",
+				"n8n-nodes-base.gmail",
+				"@n8n/n8n-nodes-langchain.textClassifier",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:gmail", "ai", "integration:langchain"],
+			"triggerType": "gmail",
+			"hasAI": true,
+			"score": 83.97,
+			"scoreBreakdown": {
+				"traction": 0.532,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.667
+			},
+			"source": "https://n8n.io/workflows/3772",
+			"author": "guitarpmacc",
+			"success": true
+		},
+		{
+			"id": 4031,
+			"slug": "cold-outreach-automation-scrape-local-leads-with-dumpling-ai-4031",
+			"name": "Cold Outreach Automation: Scrape Local Leads with Dumpling AI & Call via Vapi",
+			"description": "\n### Who is this for?\n\nThis template is for sales teams, agencies, or local service providers who want to quickly generate cold outreach lists and automatically call local businesses with a Vapi AI assistant. It’s perfect for automating cold calls from scraped local listings with no manual dialing or research.\n\n---\n\n### What problem is this workflow solving?\n\nFinding leads and initiating outreach calls can be time-consuming. This workflow automates the process: it scrapes business listings from Google Maps using Dumpling AI, extracts phone numbers, filters out incomplete data, formats the numbers, and uses Vapi to make outbound AI-powered calls. Every call is logged in Google Sheets for follow-up and tracking.\n\n---\n\n### What this workflow does\n\n1. Starts manually and pulls search queries (e.g., \"plumbers in Austin\") from Google Sheets.\n2. Sends each query to Dumpling AI’s Google Maps scraping endpoint.\n3. Splits the returned business data into individual leads.\n4. Extracts key info like business name, website, and phone number.\n5. Filters to only keep leads with valid phone numbers.\n6. Formats phone numbers for Vapi dialing (adds +1).\n7. Calls each business using Vapi AI.\n8. Logs each successful call in a Google Sheet.\n\n---\n\n### Setup\n\n1. **Google Sheets Setup**\n   - Create a sheet with business search queries in the first column (e.g., `best+restaurants+in+Chicago`)\n   - Make sure the tab name is set and authorized in your credentials.\n   - Connect your Google Sheets account in the `Get Search Keywords from Google Sheets` node.\n\n2. **Dumpling AI Setup**\n   - Go to [dumplingai.com](https://www.dumplingai.com/)   \n   - Generate an API Key and connect it as a header token in the `Scrape Google Map Businesses using Dumpling AI` node\n\n3. **Vapi Setup**\n   - Sign into [Vapi](https://vapi.ai) and create an assistant\n   - Get your `assistantId` and `phoneNumberId`\n   - Insert these into the JSON payload of the `Initiate Vapi AI Call to Business` node\n   - Add your Vapi API key to the credentials section\n\n4. **Call Logging**\n   - Create another tab in your sheet (e.g., “leads”) with these headers:\n     - `company name`\n     - `phone number`\n     - `website`\n   - This will be used in the `Log Called Business Info to Sheet` node\n\n---\n\n### How to customize this workflow to your needs\n\n- Modify the business search terms in your Google Sheet to target specific industries or locations.\n- Add filters to exclude certain businesses based on ratings, keywords, or location.\n- Update your Vapi assistant script to match the type of outreach or pitch you’re using.\n- Add additional integrations (e.g., CRM logging, Slack notifications, follow-up emails).\n- Change the trigger to run on a schedule or webhook instead of manually.\n\n---\n\n### Nodes and Functions Breakdown\n\n- `Start Workflow Manually`: Initiates the automation manually for testing or controlled runs.\n- `Get Search Keywords from Google Sheets`: Reads search phrases from the spreadsheet.\n- `Scrape Google Map Businesses using Dumpling AI`: Sends each search query to Dumpling AI and receives matching local business data.\n- `Split Each Business Result`: Breaks the returned array of businesses into individual records for processing.\n- `Extract Business Name, Phone and website`: Extracts title, phone, and website from each business record.\n- `Filter Valid Phone Numbers Only`: Ensures only entries with a phone number move forward.\n- `Format Phone Number for Calling`: Adds a +1 country code and strips non-numeric characters.\n- `Initiate Vapi AI Call to Business`: Uses the business name and number to initiate a Vapi AI outbound call.\n- `Log Called Business Info to Sheet`: Appends business details into a Google Sheet for tracking.\n\n---\n\n### Notes\n\n- You must have valid API keys and authorized connections for Dumpling AI, Google Sheets, and Vapi.\n- Make sure to handle API rate limits if you're running the workflow on large datasets.\n- This workflow is optimized for US-based leads (+1 country code); adjust the formatting node if calling internationally.\n\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.filter"
+			],
+			"tags": ["trigger:manual", "integration:googleSheets"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 83.96,
+			"scoreBreakdown": {
+				"traction": 0.531,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.667
+			},
+			"source": "https://n8n.io/workflows/4031",
+			"author": "yang",
+			"success": true
+		},
+		{
+			"id": 3638,
+			"slug": "build-your-own-custom-api-mcp-server-3638",
+			"name": "Build your own CUSTOM API MCP server",
+			"description": "### This n8n demonstrates how any organisation can quickly and easily build and offer MCP servers to their customers or internal staff to improve productivity.\n\nThis MCP example uses PayCaptain.com as an example and shows how to create an MCP server which can search for and update employee data.\n\n### How it works\n* A MCP server trigger is used and connected to 3 custom workflow tools: Search Employee, Get Employee by ID and Update Employee.\n* Each tool makes calls to the PayCaptain API to perform their respective tasks. Extra care  is performed to strip out sensitive data and ensure we're not sharing too much.\n* The Update Employee too also guards against updating fields which would preferably remain readonly. When you control the MCP server, you can determine behaviour of the tool.\n* Finally, a Google Sheet node is used to log all operations for later audit. This will add a tiny bit of latency but recommended if sensitive data is being accessed.\n\n### How to use\n* This MCP server allows any compatible MCP client to manage their PayCaptain employee database. You will need to have a PayCaptain account and developer key to use it.\n* Connect your MCP client by following the n8n guidelines here - https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-langchain.mcptrigger/#integrating-with-claude-desktop\n* Try the following queries in your MCP client:\n  * \"When did Sarah start here employment at the company?\"\n  * \"Does Jack work Wednesdays or Fridays?\"\n  * \"Please update Tracy's NI number to ABCD123456\"\n\n### Requirements\n* PayCaptain Account and Developer Key.\n* Google Sheets to log actions for later audit.\n* MCP Client or Agent for usage such as Claude Desktop - https://claude.ai/download\n\n### Customising this workflow\n* Add or remove employee attributes as required for your user case.\n* If Google Sheets is too slow, consider an API call to a faster service to log calls to the MCP server.\n* Remember to set the MCP server to require credentials before going to production and sharing this MCP server with others!",
+			"nodes": [
+				"n8n-nodes-base.executeWorkflowTrigger",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.mcpTrigger",
+				"@n8n/n8n-nodes-langchain.toolWorkflow",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.aggregate",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.if"
+			],
+			"tags": ["trigger:other", "ai", "integration:set"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 83.93,
+			"scoreBreakdown": {
+				"traction": 0.572,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.5
+			},
+			"source": "https://n8n.io/workflows/3638",
+			"author": "jimleuk",
+			"success": true
+		},
+		{
+			"id": 5629,
+			"slug": "multi-channel-workflow-error-alerts-with-telegram-gmail-mess-5629",
+			"name": "Multi-Channel Workflow Error Alerts with Telegram, Gmail & Messaging Apps",
+			"description": "The **Error Notification workflow** is designed to instantly notify you whenever any other n8n workflow encounters an error, using popular communication channels like Telegram and Gmail—with optional support for Discord, Slack, and WhatsApp. \n\n## 💡 Why Use Error Notification workflow?\n\n- **Immediate Awareness:** Get instant alerts when workflows fail, preventing unnoticed errors and downtime.\n- **Multi-Channel Flexibility:** Notify your team via Telegram, Gmail, and optionally Slack, Discord, or WhatsApp.\n- **Detailed Context:** Receive rich error information including the error message, node name, time, and execution link for quicker fixes.\n- **Easy Integration:** Built with native n8n nodes and customizable code, simple to adopt without complex setup.\n- **Open Source & Free:** Use and adapt this workflow at no cost, making professional error monitoring accessible.\n\n## ⚡ Who Is This For?\n\n- **n8n Workflow Developers:** Quickly spot and respond to automation issues in development or production.\n- **Operations Teams:** Maintain uptime and swiftly troubleshoot errors across multiple workflows.\n- **Small to Medium Businesses:** Gain professional error alerting without expensive monitoring tools.\n- **Automation Enthusiasts:** Enhance your automation reliability with real-time failure notifications.\n\n## ❓ What Problem Does It Solve?\n\nThis workflow embedd error detection and notification directly within your n8n instance. It automates the process of catching errors as they occur, compiling meaningful context, and delivering it instantly via your preferred messaging platforms. This drastically reduces your response time to issues and streamlines error management, improving your automation reliability and operational confidence.\n\n## 🔧 What This Workflow Does\n\n⏱ **Trigger:** Listens for any error generated in your n8n workflows using the n8n Error Trigger node.\n\n📎 **Step 2:** Executes a Code node that formats a detailed error message capturing workflow name, error node, description, timestamp, and an execution URL.\n\n🔍 **Step 3:** Sends the formatted error notification to multiple communication channels: Telegram and Gmail by default, plus optionally Discord, Slack, and WhatsApp (disabled by default).\n\n💌 **Step 4:** Delivers rich, parsed HTML-formatted messages to ensure error readability and immediate actionability.\n\n## 🔐 Setup Instructions\n\n1. **Import** the provided `.json` file into your **[n8n instance](https://n8n.partnerlinks.io/khaisastudio) (Cloud or self-hosted)**.\n\n2. **Set up credentials:**\n   - Gmail OAuth credentials for sending emails via Gmail node\n   - Telegram API credentials for Telegram notifications\n   - (Optional) Discord Webhook URL credential for Discord notifications\n   - (Optional) Slack Webhook credential for Slack notifications\n   - (Optional) WhatsApp connection credentials (if enabled)\n\n3. **Customize** the Code node if needed to adjust the error message format or target chat IDs.\n\n4. **Update** the chat IDs and recipient details in each notification node according to your channels.\n\n5. **Test** the workflow by manually triggering an error in another workflow to verify proper notifications.\n\n## 🧩 Pre-Requirements\n\n- Active n8n instance (cloud or self-hosted) with version supporting Error Trigger node\n- Telegram bot credentials and chat ID\n- (Optional) Gmail, Discord, Slack, or WhatsApp accounts and webhook credentials if you want to use those channels\n\n## 🛠️ Customize It Further\n\n- Enable and configure additional notification nodes like Slack or WhatsApp to fit your team's communication style.\n- Customize the error message template in the Code node to include extra metadata or format it differently (e.g., markdown).\n- Integrate with incident management tools via webhook nodes or create tickets automatically on error.\n\n## 🧠 Nodes Used\n\n- Error Trigger\n- Code\n- Telegram\n- Gmail\n- Discord (disabled)\n- Slack (disabled)\n- WhatsApp (disabled)\n- Sticky Note (for description)\n\n## 📞 Support\n\n**Made by:** [khaisa Studio](http://khaisa.studio)  \n**Tag:** notification,error,monitoring,workflow,automation,alerts  \n**Category:** Monitoring & Alerts  \n**Need a custom?** Need a custom? contact me on **[LinkedIn](https://www.linkedin.com/in/khmuhtadin/)** or **[Web](khmuhtadin.com)**",
+			"nodes": [
+				"n8n-nodes-base.errorTrigger",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.gmail",
+				"n8n-nodes-base.whatsApp",
+				"n8n-nodes-base.slack",
+				"n8n-nodes-base.telegram",
+				"n8n-nodes-base.discord",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:other", "integration:code"],
+			"triggerType": "other",
+			"hasAI": false,
+			"score": 83.89,
+			"scoreBreakdown": {
+				"traction": 0.445,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 1
+			},
+			"source": "https://n8n.io/workflows/5629",
+			"author": "khmuhtadin",
+			"success": true
+		},
+		{
+			"id": 11460,
+			"slug": "automate-3d-body-model-generation-from-images-using-sam-3d-g-11460",
+			"name": "Automate 3D Body Model Generation from Images Using SAM-3D & Google Sheets",
+			"description": "This workflow automates the process of **generating 3D human body models** (in `.glb` format) from **single image** using  SAM-3D model. It operates by connecting a Google Sheet as a data source with the external AI processing API. \n\n| Start | Result|\n|--------|---------|\n| ![image](https://n3wstorage.b-cdn.net/n3witalia/golf-swing.jpg) | ![image](https://n3wstorage.b-cdn.net/n3witalia/golf-swing-result.png) |\n\n\n\n---\n\n### **Use Cases**\n\n#### **1. ✅ Sports Analysis & Motion Optimization**\n\n3D models allow precise analysis of posture, angles, and technique.\nPossible applications:\n\n* **Golf swing analysis**\n  Identify stance, rotation, shoulder/hip alignment, and follow-through.\n* **Tennis serve biomechanics**\n  Optimize shoulder rotation, racket angle, leg push-off.\n* **Running gait analysis**\n  Evaluate stride symmetry, foot strike, and body tilt.\n* **Cycling posture optimization**\n  Reduce drag by analyzing torso angle and hand position.\n* **Swimming technique evaluations**\n  Compare ideal vs. actual joint angles.\n\n#### **2. ✅ Fitness, Health & Physiotherapy**\n\n3D models can visually highlight imbalances or incorrect positions.\n\n* **Posture correction assessments**\n  Identify spinal misalignment or uneven weight distribution.\n* **Physical therapy progress tracking**\n  Compare poses over time to assess recovery.\n* **Ergonomics and workplace safety**\n  Evaluate whether a worker’s posture is safe during lifting or repetitive tasks.\n* **Home fitness coaching**\n  Automated feedback for yoga, pilates, stretching exercises.\n\n#### **3. ✅ Fashion, Apparel & Virtual Try-On**\n\nPhotorealistic body reconstruction helps generate tailored outfits or evaluate fit.\n\n* **Virtual try-on for clothing brands**\n  Produce accurate 3D avatars to test garments digitally.\n* **Custom-made fashion**\n  Use 3D measurements for bespoke tailoring patterns.\n* **Model pose simulation**\n  Test clothing fit in dynamic or unusual positions (e.g., dance, athletic poses).\n\n#### **4. ✅ Gaming, Animation & Digital Content Creation**\n\nQuick 3D reconstruction reduces production time for digital humans.\n\n* **Character rigging from real people**\n  Generate 3D avatars ready for animation.\n* **Motion capture alternatives**\n  Recreate specific poses without expensive mocap systems.\n* **VR/AR content creation**\n  Deploy 3D characters into immersive environments.\n* **Comics, illustration, and concept art**\n  Use 3D poses as reference models to speed up drawing.\n\n#### **5. ✅ Medical, Research & Educational Applications**\n\nHuman-body 3D models provide insights in scientific or practical contexts.\n\n* **Anthropometric measurements**\n  Estimate height, limb length, body proportions from images.\n* **Posture and musculoskeletal studies**\n  Analyze joint angle distribution in different poses.\n* **Rehabilitation robotics or exoskeleton design**\n  Fit devices to a patient’s real body shape.\n* **Training materials for anatomy or movement science**\n  Generate accurate pose examples for students.\n\n#### **6.✅  Security, Forensics & Reconstruction**\n\nWhen allowed ethically and legally, 3D models can support investigations.\n\n* **Reconstruction of accident scenes**\n  Understand how a person fell, collided, or moved.\n* **Analysis of body posture in video frames**\n  Useful for determining gesture patterns or mobility constraints.\n\n#### **7. ✅ Art, Photography & Creative Industries**\n\nArtists often need unusual or complex human poses.\n\n* **Pose reference creation**\n  For painting, 3D sculpting, illustration, or storyboarding.\n* **Recreating dynamic action scenes**\n  Parkour, martial arts, ballet, expressive dance.\n* **Virtual studio lighting tests**\n  Apply simulated lighting to a 3D model before shooting.\n\n---\n\n### **How It Works**\n\nThis workflow automates the process of generating 3D human body models (in `.glb` format) from single images using the FAL.AI SAM-3D service. It operates by connecting a Google Sheet as a data source with the external AI processing API. Here is the operational flow:\n\n1.  **Trigger & Data Fetch:** The workflow begins either manually (via \"Test workflow\") or on a schedule. It queries a designated Google Sheet to find rows where the \"3D RESULT\" column is empty, indicating a new image needs processing.\n2.  **API Request & Queuing:** For each new image, it sends the image URL to the FAL.AI SAM-3D API endpoint (`/fal-ai/sam-3/3d-body`), which queues the job and returns a unique `request_id`.\n3.  **Status Polling & Waiting:** The workflow enters a polling loop. It waits 60 seconds, then checks the job's status using the `request_id`. If the status is not \"COMPLETED\", it waits another 60 seconds and checks again.\n4.  **Result Retrieval & Storage:** Once the status is \"COMPLETED\", the workflow fetches the final result, which contains the URL of the generated 3D model file (`.glb`). This file is then downloaded via an HTTP request.\n5.  **Sheet Update:** Finally, the workflow updates the original Google Sheet row. It writes the URL of the generated 3D model into the \"IMAGE RESULT\" column for the corresponding `row_number`, thus marking the task as complete.\n\n\n---\n\n### **Set Up Steps**\n\nTo configure this workflow in your n8n environment, follow these steps:\n\n1.  **Prepare the Google Sheet:**\n    *   Clone the provided Google Sheet template.\n    *   Insert the URLs of the model images you want to convert into the \"IMAGE MODEL\" column.\n    *   Leave the \"IMAGE RESULT\" column empty; it will be populated automatically.\n    *   In n8n, set up a \"Google Sheets OAuth2 API\" credential and connect it to the **Get new image** and **Update result** nodes. Ensure the `documentId` points to your cloned sheet.\n\n2.  **Configure the FAL.AI API Connection:**\n    *   Create an account at [fal.ai](https://fal.ai/) and obtain your API key.\n    *   In n8n, create an \"HTTP Header Auth\" credential. Set the **Header Name** to `Authorization` and the **Header Value** to `Key YOUR_API_KEY_HERE` (replace with your actual key).\n    *   Apply this credential to the following nodes: **Create 3D Image**, **Get status**, and **Get Url 3D image**.\n\n3.  **Verify Workflow Logic (Key Nodes):**\n    *   **Get new image:** Confirm the `filtersUI` is set to look for empty rows in the correct column (e.g., \"3D RESULT\" or \"IMAGE RESULT\").\n    *   **Create 3D Image:** Verify the JSON body correctly references the image URL from the previous node (`{{ $json.image }}`).\n    *   **Completed? (If node):** Ensure the condition checks for the string `COMPLETED` from `{{ $json.status }}`.\n    *   **Update result:** Double-check that the column mapping correctly uses `row_number` to match the row and updates the \"IMAGE RESULT\" column with the GLB URL \n4.  **Activate & Test:**\n    *   Save the workflow.\n    *   Use the **When clicking ‘Test workflow’** node for an initial manual test with one image URL in your sheet.\n    *   Once confirmed working, you can enable the **Schedule Trigger** node for automatic, periodic execution.\n\n---\n\n👉 [Subscribe to my new **YouTube channel**](https://youtube.com/@n3witalia). Here I’ll share videos and Shorts with practical tutorials and **FREE templates for n8n**.\n\n[![image](https://n3wstorage.b-cdn.net/n3witalia/youtube-n8n-cover.jpg)](https://youtube.com/@n3witalia)\n\n---\n\n### **Need help customizing?**  \n[Contact me](mailto:info@n3w.it) for consulting and support or add me on [Linkedin](https://www.linkedin.com/in/davideboizza/).",
+			"nodes": [
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.wait",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.googleSheets",
+				"n8n-nodes-base.set"
+			],
+			"tags": ["trigger:manual", "integration:httpRequest"],
+			"triggerType": "manual",
+			"hasAI": false,
+			"score": 83.87,
+			"scoreBreakdown": {
+				"traction": 0.535,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.636
+			},
+			"source": "https://n8n.io/workflows/11460",
+			"author": "n3witalia",
+			"success": true
+		},
+		{
+			"id": 13651,
+			"slug": "generate-ai-trading-alerts-from-coingecko-and-alpha-vantage--13651",
+			"name": "Generate AI trading alerts from CoinGecko and Alpha Vantage via Slack, email and SMS",
+			"description": "Automates real-time market monitoring, technical analysis, AI-powered signal generation for cryptocurrencies (and stocks), filters high-confidence trades, and delivers actionable alerts via multiple channels.\n\n## Good to Know\n- Runs **every 5–30 minutes** (configurable trigger) to catch fresh market opportunities\n- Pulls **real-time price data** from multiple crypto/stock sources in parallel\n- Calculates popular **technical indicators** (RSI, MACD, Moving Averages, etc.)\n- Uses an **AI model** (likely Grok/xAI, OpenAI, or similar) to interpret indicators and generate buy/sell signals with confidence scores\n- Applies **multi-layer filtering** to reduce noise (thresholds, validation rules)\n- Stores signals in a **database**, logs execution history, and sends notifications\n- Supports **email**, **Telegram**, **Discord**, **SMS** (via Twilio), or **trading execution** webhooks\n- Saves significant time compared to manual chart watching\n\n## How It Works\n\n### 1. Trigger\n- **Schedule Trigger** or **Manual Trigger** (every 5–30 minutes)\n- Optional: **Market Hours / Kill-zone** filter (e.g. avoid low-volume periods)\n- Can be webhook-based for on-demand runs\n\n### 2. Fetch & Prepare Data\n- Fetches **real-time / recent OHLCV data** for a watchlist of cryptocurrencies (and possibly stocks)\n- Sources: CoinGecko, Binance, Alpha Vantage, CoinMarketCap, Bybit, Kraken, etc. (multiple in parallel)\n- Combines data from different APIs\n- Prepares structured dataset (candles, volume, current price)\n- Calculates **technical indicators** in parallel or via Code node / community nodes (e.g. RSI(14), MACD, EMA/SMA crossovers, Bollinger Bands, etc.)\n\n### 3. Analysis & Signal Generation\n- Sends prepared market data + calculated indicators to an **AI model**\n- Prompt instructs the model to:\n  - Analyze current market structure\n  - Evaluate indicator confluence\n  - Generate **Buy / Sell / Hold** signal\n  - Assign **confidence score** (e.g. 0–100%)\n  - Provide short reasoning\n- Optional: Rule-based pre-filter (e.g. only proceed if RSI &lt; 30 or MACD crossover)\n\n### 4. Validate, Alert & Store\n- **Filters** signals: minimum confidence threshold, no-duplicate check, max signals per run, etc.\n- **Validates** against additional rules (e.g. volume spike, no recent opposite signal)\n- **Stores** signal in database (PostgreSQL, Supabase, Airtable, Google Sheets, etc.)\n  - Includes: timestamp, symbol, signal type, confidence, price, indicators snapshot, AI reasoning\n- **Logs** full execution trace\n- **Sends alerts**:\n  - Email notification\n  - Telegram / Discord message (with formatting)\n  - SMS (Twilio)\n  - Webhook to trading bot / execution system\n  - Optional: Push to tradingview alert or auto-execute (paper/live)\n\n## Data Sources\n- **Market Data APIs** — CoinGecko, Binance, Alpha Vantage, CoinMarketCap, etc.\n- **Technical Indicators** — Calculated via Code node, community nodes (e.g. phoenix indicators), or external libraries\n- **AI Model** — Grok (xAI), OpenAI (GPT-4o), Claude, Gemini, or local LLM\n- **Notification Channels** — Email (Gmail/SMTP), Telegram, Discord, Twilio, webhook\n- **Storage** — Google Sheets, PostgreSQL, Supabase, Notion, Airtable\n\n## How to Use\n1. **Import** the workflow JSON into your n8n instance\n2. **Configure credentials**:\n   - API keys for market data providers (Alpha Vantage, CoinGecko Pro, Binance, etc.)\n   - AI provider (Grok API key, OpenAI key, etc.)\n   - Notification services (Telegram bot token, email SMTP, Twilio, etc.)\n   - Database connection if used\n3. **Set your watchlist** — edit the symbols in the fetch node(s)\n4. **Tune the schedule** — change interval in the trigger node\n5. **Customize AI prompt** — adjust in the AI node for more aggressive/conservative signals\n6. **Set filters** — confidence threshold, max alerts per cycle, etc.\n7. **Test manually** — use Execute Workflow button with sample data\n8. **Activate & monitor** — check Executions tab for logs\n\n## Requirements\n- n8n (self-hosted or cloud)\n- API keys for at least one market data provider\n- AI API access (Grok, OpenAI, etc.)\n- Notification credentials (Telegram bot, email account, etc.)\n- Optional: Database for persistent signal history\n\n## Customizing This Workflow\n- Add more **exchanges/sources** for better data redundancy\n- Include **on-chain metrics** (whale alerts, funding rates) via additional APIs\n- Switch AI model or fine-tune prompt for your trading style\n- Add **risk management** rules (position sizing, stop-loss levels)\n- Integrate **auto-trading** via exchange API (Binance, Bybit, Alpaca, etc.)\n- Create **dashboard** output (Google Sheets + Looker Studio / Grafana)\n- Add **backtesting mode** using historical data\n- Implement **blackout periods** or news filter to avoid high-impact events\n",
+			"nodes": [
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.merge",
+				"n8n-nodes-base.code",
+				"n8n-nodes-base.filter",
+				"n8n-nodes-base.postgres",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.emailSend"
+			],
+			"tags": ["trigger:schedule", "integration:httpRequest"],
+			"triggerType": "schedule",
+			"hasAI": false,
+			"score": 83.1,
+			"scoreBreakdown": {
+				"traction": 0.521,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0,
+				"clarity": 1,
+				"density": 0.533
+			},
+			"source": "https://n8n.io/workflows/13651",
+			"author": "oneclick-ai",
+			"success": true
+		},
+		{
+			"id": 3675,
+			"slug": "mcp-supabase-server-for-ai-agent-with-rag-multi-tenant-crud-3675",
+			"name": "MCP Supabase Server for AI Agent with RAG & Multi-Tenant CRUD",
+			"description": "# Supabase AI Agent with RAG & Multi-Tenant CRUD  \n**Version**: 1.0.0  \n**n8n Version**: 1.88.0+  \n**Author**: Koresolucoes \n**License**: MIT  \n\n---\n\n## Description  \nA stateful AI agent workflow powered by **Supabase** and **Retrieval-Augmented Generation (RAG)**. Enables persistent memory, dynamic CRUD operations, and multi-tenant data isolation for AI-driven applications like customer support, task orchestration, and knowledge management.  \n\n**Key Features**:  \n- 🧠 **RAG Integration**: Leverages OpenAI embeddings and Supabase vector search for context-aware responses.  \n- 🗃️ **Full CRUD**: Manage `agent_messages`, `agent_tasks`, `agent_status`, and `agent_knowledge` in real time.  \n- 📤 **Multi-Tenant Ready**: Supports per-user/organization data isolation via dynamic table names and webhooks.  \n- 🔒 **Secure**: Role-based access control via Supabase Row Level Security (RLS).  \n\n---\n\n## Use Cases  \n1. **Customer Support Chatbots**: Persist conversation history and resolve queries using institutional knowledge.  \n2. **Automated Task Management**: Track and update task statuses dynamically.  \n3. **Knowledge Repositories**: Store and retrieve domain-specific information for AI agents.  \n\n---\n\n## Instructions  \n### 1. Import Template  \n- Go to **n8n &gt; Templates &gt; Import from File** and upload this workflow.  \n\n### 2. Configure Credentials  \n- Add your **Supabase** and **OpenAI** API keys under **Settings &gt; Credentials**.  \n\n### 3. Set Up Multi-Tenancy (Optional)  \n- **Dynamic Webhook Path**:  \n  Replace the default webhook path with `/mcp/tool/supabase/:userId` to enable per-user routing.  \n- **Table Names**:  \n  Use a **Set Node** to dynamically generate table names (e.g., `agent_messages_{{userId}}`).  \n\n### 4. Activate & Test  \n- Enable the workflow and send test requests to the webhook URL.  \n\n---\n\n## Tags  \n`AI Agent` `RAG` `Supabase` `CRUD` `Multi-Tenant` `OpenAI` `Automation`  \n\n---\n\n## Screenshots  \n![Captura de tela 20250423 124013.png](fileId:1158)\n![Captura de tela 20250423 123954.png](fileId:1159)\n\n---\n\n## License  \nThis template is licensed under the MIT License.  ",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.mcpTrigger",
+				"@n8n/n8n-nodes-langchain.vectorStoreSupabase",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.supabaseTool"
+			],
+			"tags": ["trigger:other", "ai", "integration:supabaseTool"],
+			"triggerType": "other",
+			"hasAI": true,
+			"score": 82.03,
+			"scoreBreakdown": {
+				"traction": 0.558,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.174
+			},
+			"source": "https://n8n.io/workflows/3675",
+			"author": "koresoluciones",
+			"success": true
+		},
+		{
+			"id": 12400,
+			"slug": "handle-customer-support-queries-with-cache-first-rag-using-r-12400",
+			"name": "Handle customer support queries with cache-first RAG using Redis, LangCache and OpenAI",
+			"description": "\nAn end-to-end **Retrieval-Augmented Generation (RAG)** customer support workflow for **n8n**, using a **cache-first strategy (LangCache)** combined with a **Redis vector store** powered by **OpenAI embeddings**.  \nThis template is designed for fast, accurate, and cost-efficient customer support chatbots, internal help desks, and knowledge-base assistants.\n\n---\n\n## Overview\n\nThis workflow implements a **production-ready RAG architecture** optimized for customer support use cases. Incoming chat messages are processed through a structured pipeline that prioritizes cached answers, falls back to semantic vector search when needed, and validates response quality before returning a final answer.\n\nThe workflow supports:\n- Multi-question user inputs\n- Intelligent query decomposition\n- Cache reuse to reduce latency and cost\n- High-precision retrieval from a Redis vector database\n- Quality evaluation and controlled retries\n- Final answer synthesis into a single, coherent response\n\n---\n\n## Key Features\n\n- **Chat-based RAG pipeline** using n8n’s Chat Trigger\n- **Query decomposition** for multi-topic questions\n- **LangCache integration** (search + save)\n- **Redis Vector Store** for semantic retrieval\n- **OpenAI embeddings and chat models**\n- **Quality scoring** with retry logic\n- **Session memory buffers** for contextual continuity\n- **Fallback-safe behavior** (no hallucinations)\n\n---\n\n## How the Workflow Works\n\n### 1. Chat Trigger\nThe workflow starts when a new chat message is received.\n\n### 2. Configuration Setup\nA centralized configuration node defines:\n- LangCache base URL\n- Cache ID\n- Similarity threshold (default: `0.75`)\n- Maximum retrieval iterations (default: `2`)\n\n### 3. Query Decomposition\nThe user message is analyzed and decomposed into:\n- A single focused question, or\n- Multiple independent sub-questions\n\nThis improves retrieval accuracy and cache reuse.\n\n### 4. Cache-First Retrieval\nEach sub-question is processed independently:\n- The workflow first searches **LangCache**\n- If a high-similarity cached answer is found, it is reused immediately\n\n### 5. Vector Retrieval (Cache Miss)\nIf no cache hit exists:\n- The query is embedded using OpenAI embeddings\n- A semantic search is executed against the **Redis vector index**\n- Retrieved knowledge-base documents are passed to a research-only agent\n\n### 6. Knowledge-Only Answering\nThe research agent:\n- Answers **strictly from the retrieved knowledge**\n- Returns `\"no info found\"` if no relevant data exists\n\n### 7. Quality Evaluation\nEach generated answer is evaluated by a dedicated quality-check node:\n- Outputs a numerical `SCORE` (0.0 – 1.0)\n- Provides textual feedback\n- Low scores can trigger limited retries\n\n### 8. Cache Update\nHigh-quality answers are saved back to **LangCache** for future reuse.\n\n### 9. Aggregation & Synthesis\nAll sub-answers are aggregated and synthesized into:\n- One final, user-facing response, or\n- A polite fallback message if information is insufficient\n\n---\n\n## Main Nodes & Responsibilities\n\n- **When Chat Message Received** — Entry point for user messages\n- **LangCache Config** — Centralized configuration values\n- **Decompose Query (LangChain Agent)** — Splits complex queries\n- **Structured Output Parser** — Ensures valid JSON output\n- **Search LangCache** — Cache lookup via HTTP\n- **Redis Vector Store** — Semantic retrieval from Redis\n- **Embeddings OpenAI** — Vector generation\n- **Research Agent** — KB-only answering (no hallucinations)\n- **Quality Evaluator** — Scores answer relevance\n- **Save to LangCache** — Stores validated answers\n- **Memory Buffers** — Session context handling\n- **Response Synthesizer** — Final message generation\n\n---\n\n## Setup Instructions\n\n### 1. Configure Credentials\nCreate the following credentials in n8n:\n- **OpenAI API**\n- **Redis**\n- **HTTP Bearer Auth** (for LangCache)\n\n### 2. Prepare the Knowledge Base\n- Embed your documents using OpenAI embeddings\n- Insert them into the configured Redis vector index\n- Ensure documents are concise and well-structured\n\n### 3. Configure LangCache\nUpdate the configuration node with:\n- `langcacheBaseUrl`\n- `langcacheCacheId`\n- Optional tuning for similarity threshold and iterations\n\n### 4. Test the Workflow\n- Use the example data loader or schedule trigger\n- Send test chat messages\n- Validate cache hits, vector retrieval, and final responses\n\n---\n\n## Recommended Tuning\n\n- **Similarity Threshold:** `0.7 – 0.85`\n- **Max Iterations:** `1 – 3`\n- **Quality Score Cutoff:** `0.7`\n- **Model Choice:** Use faster models for low latency, stronger models for accuracy\n- **Cache Policy:** Cache only high-confidence answers\n\n---\n\n## Security & Compliance Notes\n\n- Store API keys securely using n8n credentials\n- Avoid caching sensitive or personally identifiable information\n- Apply least-privilege access to Redis and LangCache\n- Consider logging cache writes for audit purposes\n\n---\n\n## Common Use Cases\n\n- Customer support chatbots\n- Internal help desks\n- Knowledge-base assistants\n- Self-service support portals\n- AI-powered FAQ systems\n\n---\n\n## Template Metadata (Recommended)\n\n- **Template Name:** AI Customer Support — Redis RAG (LangCache + OpenAI)\n- **Category:** Customer Support / AI / RAG\n- **Tags:**  \n  `customer-support`, `RAG`, `knowledge-base`, `redis`, `openai`, `langcache`, `chatbot`, `n8n-template`\n- **Difficulty Level:** Intermediate\n- **Required Integrations:** OpenAI, Redis, LangCache\n",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.outputParserStructured",
+				"n8n-nodes-base.splitOut",
+				"n8n-nodes-base.httpRequest",
+				"n8n-nodes-base.if",
+				"n8n-nodes-base.set",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.aggregate",
+				"@n8n/n8n-nodes-langchain.vectorStoreRedis",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.openAi",
+				"n8n-nodes-base.scheduleTrigger",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:langchain"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 77.65,
+			"scoreBreakdown": {
+				"traction": 0.24,
+				"recency": 1,
+				"coverage": 1,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.571
+			},
+			"source": "https://n8n.io/workflows/12400",
+			"author": "mohelwah",
+			"success": true
+		},
+		{
+			"id": 5010,
+			"slug": "rag-starter-template-using-simple-vector-stores-form-trigger-5010",
+			"name": "RAG Starter Template using Simple Vector Stores, Form trigger and OpenAI",
+			"description": "This template quickly shows how to use RAG in n8n.\n\n## Who is this for?\nThis template is for everyone who wants to start giving knowledge to their Agents through RAG.\n\n## Requirements\nHave a PDF with custom knowledge that you want to provide to your agent.\n\n## Setup\nNo setup required. Just hit `Execute Workflow`, upload your knowledge document and then start chatting.\n\n## How to customize this to your needs\n1. Add custom instructions to your Agent by changing the prompts in it.\n2. Add a different way to load in knowledge to your vector store, e.g. by looking at some Google Drive files or loading knowledge from a table.\n2. Exchange the `Simple Vector Store` nodes with your own vector store tools ready for production.\n3. Add a more sophisticated way to rank files found in the vector store.\n\nFor more information read our [docs on RAG in n8n](https://docs.n8n.io/advanced-ai/rag-in-n8n/).\n\n",
+			"nodes": [
+				"n8n-nodes-base.formTrigger",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi",
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"n8n-nodes-base.stickyNote",
+				"@n8n/n8n-nodes-langchain.vectorStoreInMemory",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi"
+			],
+			"tags": ["trigger:formTrigger", "ai", "integration:langchain"],
+			"triggerType": "formTrigger",
+			"hasAI": true,
+			"score": 72.06,
+			"scoreBreakdown": {
+				"traction": 0.759,
+				"recency": 1,
+				"coverage": 0.5,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.875
+			},
+			"source": "https://n8n.io/workflows/5010",
+			"author": "n8n-team",
+			"success": true
+		},
+		{
+			"id": 3647,
+			"slug": "transform-google-drive-documents-into-vector-embeddings-3647",
+			"name": "📥 Transform Google Drive Documents into Vector Embeddings",
+			"description": "Automatically convert documents from Google Drive into vector embeddings using OpenAI, LangChain, and PGVector — fully automated through n8n.\n\n---\n\n### ⚙️ What It Does\n\nThis workflow monitors a Google Drive folder for new files, supports multiple file types (PDF, TXT, JSON), and processes them into vector embeddings using OpenAI’s `text-embedding-3-small` model. These embeddings are stored in a Postgres database using the PGVector extension, making them query-ready for semantic search or RAG-based AI agents.\n\nAfter successful processing, files are moved to a separate “vectorized” folder to avoid duplication.\n\n---\n\n### 💡 Use Cases\n\n- Powering Retrieval-Augmented Generation (RAG) AI agents  \n- Semantic search across private documents  \n- AI assistant knowledge ingestion  \n- Automated document pipelines for indexing or classification  \n\n---\n\n### 🧠 Workflow Highlights\n\n- **Trigger Options:** Manual or Scheduled (3 AM daily by default)  \n- **Supported File Types:** PDF, TXT, JSON  \n- **Embedding Stack:** LangChain Text Splitter, OpenAI Embeddings, PGVector  \n- **Deduplication:** Files are moved after processing  \n- **License:** CC BY-SA 4.0  \n- **Author:** [AlexK1919](https://www.alexk1919.com)\n\n---\n\n### 🛠 What You’ll Need\n\n- **Google Drive OAuth2** credentials (connected to `Search Folder`, `Download File`, and `Move File` nodes)  \n- **OpenAI API Key** (used in the `Embeddings OpenAI` node)  \n- **Postgres + PGVector** database (connected in the `Postgres PGVector Store` node)\n\n---\n\n### 🔧 Step-by-Step Setup Instructions\n\n1. **Create Google OAuth2 credentials** in n8n and connect them to all Google Drive nodes.\n2. **Set your source folder** ID in the `Search Folder` node — this is where incoming files are placed.\n3. **Set your processed folder** ID in the `Move File` node — files will be moved here after vectorization.\n4. **Ensure you have a PGVector-enabled Postgres instance** and input the table name and collection in the `Postgres PGVector Store` node.\n5. **Add your OpenAI credentials** to the `Embeddings OpenAI` node and select `text-embedding-3-small`.\n6. **Optional:** Activate the `Schedule Trigger` node to run daily or configure your own schedule.\n7. **Run manually** by triggering `When clicking ‘Test workflow’` for on-demand ingestion.\n\n---\n\n### 🧩 Customization Tips\n\nWant to support more file types or enhance the pipeline?\n\n- **Add new extractors**: Use `Extract from File` with other formats like DOCX, Markdown, or HTML.\n- **Refine logic by file type**: The `Switch` node routes files to the correct extraction method based on MIME type (`application/pdf`, `text/plain`, `application/json`).\n- **Pre-process with OCR**: Add an OCR step before extraction to handle scanned PDFs or images.\n- **Add filters**: Enhance the `Search Folder` or `Switch` node logic to skip specific files or folders.\n\n---\n\n### 📄 License\n\nThis workflow is available under Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license. You are free to use, adapt, and share this workflow for non-commercial purposes under the terms of this license.\n\nFull license details: https://creativecommons.org/licenses/by-nc-sa/4.0/",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter",
+				"@n8n/n8n-nodes-langchain.vectorStorePGVector",
+				"n8n-nodes-base.manualTrigger",
+				"n8n-nodes-base.splitInBatches",
+				"n8n-nodes-base.googleDrive",
+				"n8n-nodes-base.scheduleTrigger",
+				"n8n-nodes-base.stickyNote",
+				"n8n-nodes-base.switch",
+				"n8n-nodes-base.extractFromFile",
+				"@n8n/n8n-nodes-langchain.embeddingsOpenAi"
+			],
+			"tags": ["trigger:manual", "ai", "integration:langchain"],
+			"triggerType": "manual",
+			"hasAI": true,
+			"score": 66.66,
+			"scoreBreakdown": {
+				"traction": 0.529,
+				"recency": 1,
+				"coverage": 0.5,
+				"aiAgent": 0.6,
+				"clarity": 1,
+				"density": 0.714
+			},
+			"source": "https://n8n.io/workflows/3647",
+			"author": "alexk1919",
+			"success": true
+		},
+		{
+			"id": 3848,
+			"slug": "build-a-document-qa-system-with-rag-using-milvus-cohere-and--3848",
+			"name": "Build a Document QA System with RAG using Milvus, Cohere, and OpenAI for Google Drive",
+			"description": "\n\n### Template Description\n\nThis template creates a powerful Retrieval Augmented Generation (RAG) AI agent workflow in [n8n](https://n8n.partnerlinks.io/5xf5bs8y3ruv). It monitors a specified Google Drive folder for new PDF files, extracts their content, generates vector embeddings using Cohere, and stores these embeddings in a Milvus vector database. Subsequently, it enables a RAG agent that can retrieve relevant information from the Milvus database based on user queries and generate responses using OpenAI, enhanced by the retrieved context.\n\n### Functionality\n\nThe workflow automates the process of ingesting documents into a vector database for use with a RAG system.\n\n 1. **Watch New Files:** Triggers when a new file (specifically targeting PDFs) is added to a designated Google Drive folder.\n\n 2. **Download New:** Downloads the newly added file from Google Drive.\n\n 3. **Extract from File:** Extracts text content from the downloaded PDF file.\n\n 4. **Default Data Loader / Set Chunks:** Processes the extracted text, splitting it into manageable chunks for embedding.\n\n 5. **Embeddings Cohere:** Generates vector embeddings for each text chunk using the Cohere API.\n\n 6. **Insert into Milvus:** Inserts the generated vector embeddings and associated metadata into a Milvus vector database.\n\n 7. **When chat message received:** Adapt the trigger tool to fit your needs. \n 8. **RAG Agent:** Orchestrates the RAG process.\n\n 9. **Retrieve from Milvus:** Queries the Milvus database with the user's chat query to find the most relevant chunks.\n\n10. **Memory:** Manages conversation history for the RAG agent to optimize cost and response speed.\n\n11. **OpenAI / Cohere embeddings:** Uses ChatGPT 4o for text generation.\n\n### Requirements\n\nTo use this template, you will need:\n\n* An [n8n instance](https://n8n.partnerlinks.io/5xf5bs8y3ruv) (cloud or self-hosted).\n\n* Access to a Google Drive account to monitor a folder.\n\n* A Milvus instance or access to a Milvus cloud service like [Zilliz](https://zilliz.com). \n\n* A [Cohere](https://cohere.com) API key for generating embeddings.\n\n* An OpenAI API key for the RAG agent's text generation.\n\n### Usage\n\n1. Set up the required credentials in n8n for Google Drive, Milvus, Cohere, and OpenAI.\n\n2. Configure the \"Watch New Files\" node to point to the Google Drive folder you want to monitor for PDFs.\n\n3. Ensure your Milvus instance is running and the target cluster is set up correctly.\n\n4. Activate the workflow.\n\n5. Add PDF files to the monitored Google Drive folder. The workflow will automatically process them and insert their embeddings into Milvus.\n\n6. Interact with the RAG agent. The agent will use the data in Milvus to provide context-aware answers.\n\n### Benefits\n\n* Automates document ingestion for RAG applications.\n\n* Leverages Milvus for high-performance vector storage and search.\n\n* Uses Cohere for generating high-quality text embeddings.\n\n* Enables building a context-aware AI agent using your own documents.\n\n### Suggested improvements\n* **Support for More File Types:** Extend the \"Watch New Files\" node and subsequent extraction steps to handle various document types (e.g., .docx, .txt, .csv, web pages) in addition to PDFs.\n\n* **Error Handling and Notifications:** Implement robust error handling for each step of the workflow (e.g., failed downloads, extraction errors, Milvus insertion failures) and add notification mechanisms (e.g., email, Slack) to alert the user.\n\n### Get in touch with us\n\nContact us at [https://1node.ai](https://1node.ai) ",
+			"nodes": [
+				"@n8n/n8n-nodes-langchain.documentDefaultDataLoader",
+				"@n8n/n8n-nodes-langchain.embeddingsCohere",
+				"@n8n/n8n-nodes-langchain.chatTrigger",
+				"n8n-nodes-base.googleDriveTrigger",
+				"n8n-nodes-base.googleDrive",
+				"@n8n/n8n-nodes-langchain.vectorStoreMilvus",
+				"@n8n/n8n-nodes-langchain.agent",
+				"@n8n/n8n-nodes-langchain.lmChatOpenAi",
+				"@n8n/n8n-nodes-langchain.memoryBufferWindow",
+				"@n8n/n8n-nodes-langchain.textSplitterRecursiveCharacterTextSplitter",
+				"n8n-nodes-base.extractFromFile",
+				"n8n-nodes-base.stickyNote"
+			],
+			"tags": ["trigger:chatTrigger", "ai", "integration:langchain"],
+			"triggerType": "chatTrigger",
+			"hasAI": true,
+			"score": 65.61,
+			"scoreBreakdown": {
+				"traction": 0.444,
+				"recency": 1,
+				"coverage": 0.5,
+				"aiAgent": 1,
+				"clarity": 1,
+				"density": 0.846
+			},
+			"source": "https://n8n.io/workflows/3848",
+			"author": "aitoralonso",
+			"success": true
+		}
+	]
+}
diff --git a/packages/@n8n/workflow-sdk/examples/templates.zip b/packages/@n8n/workflow-sdk/examples/templates.zip
new file mode 100644
index 00000000000..ec29d1240b0
Binary files /dev/null and b/packages/@n8n/workflow-sdk/examples/templates.zip differ
diff --git a/packages/@n8n/workflow-sdk/jest.config.js b/packages/@n8n/workflow-sdk/jest.config.js
index d6c48554a79..7d0b53ebc78 100644
--- a/packages/@n8n/workflow-sdk/jest.config.js
+++ b/packages/@n8n/workflow-sdk/jest.config.js
@@ -1,2 +1,5 @@
 /** @type {import('jest').Config} */
-module.exports = require('../../../jest.config');
+module.exports = {
+	...require('../../../jest.config'),
+	globalSetup: '<rootDir>/scripts/jest-global-setup.ts',
+};
diff --git a/packages/@n8n/workflow-sdk/package.json b/packages/@n8n/workflow-sdk/package.json
index e2c739c0c98..df0a085d55a 100644
--- a/packages/@n8n/workflow-sdk/package.json
+++ b/packages/@n8n/workflow-sdk/package.json
@@ -37,6 +37,10 @@
     "./prompts/node-selection": {
       "types": "./dist/prompts/node-selection/index.d.ts",
       "default": "./dist/prompts/node-selection/index.js"
+    },
+    "./examples-loader": {
+      "types": "./dist/examples-loader.d.ts",
+      "default": "./dist/examples-loader.js"
     }
   },
   "scripts": {
@@ -49,7 +53,6 @@
     "lint": "eslint . --quiet",
     "lint:fix": "eslint . --fix",
     "watch": "tsc -p tsconfig.build.json --watch",
-    "pretest": "npx tsx scripts/extract-workflows.ts",
     "extract-workflows": "npx tsx scripts/extract-workflows.ts",
     "test": "jest",
     "test:unit": "jest",
@@ -57,8 +60,13 @@
     "generate-types": "npx tsx src/generate-types/generate-types.ts",
     "fetch-workflows": "npx tsx scripts/fetch-test-workflows.ts",
     "create-workflows-zip": "npx tsx scripts/create-workflows-zip.ts",
+    "create-examples-zip": "npx tsx scripts/create-examples-zip.ts",
     "json-to-code": "npx tsx src/cli/index.ts json-to-code",
-    "code-to-json": "npx tsx src/cli/index.ts code-to-json"
+    "code-to-json": "npx tsx src/cli/index.ts code-to-json",
+    "fetch-templates": "npx tsx scripts/fetch-templates.ts",
+    "regenerate-examples": "npx tsx scripts/regenerate-examples.ts",
+    "criteria:calibrate": "npx tsx scripts/calibration.ts",
+    "criteria:coverage": "npx tsx scripts/coverage.ts"
   },
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -79,11 +87,16 @@
       ],
       "prompts/node-selection": [
         "./dist/prompts/node-selection/index.d.ts"
+      ],
+      "examples-loader": [
+        "./dist/examples-loader.d.ts"
       ]
     }
   },
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "examples/manifest.json",
+    "examples/templates.zip"
   ],
   "devDependencies": {
     "@n8n/eslint-plugin-community-nodes": "workspace:*",
diff --git a/packages/@n8n/workflow-sdk/scripts/calibration.ts b/packages/@n8n/workflow-sdk/scripts/calibration.ts
new file mode 100644
index 00000000000..715b4947b65
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/calibration.ts
@@ -0,0 +1,179 @@
+/**
+ * Calibration runner.
+ *
+ * Loads `examples/_calibration.json` (hand-tagged expert verdicts), runs the
+ * rubric over each entry, and reports:
+ *   - Spearman rank correlation between rubric scores and expert verdicts
+ *   - Top disagreements with explanations
+ *
+ * Usage: pnpm criteria:calibrate
+ *
+ * The calibration file is a manually maintained JSON. Tagging convention:
+ *   { id: 1954, verdict: 'helpful' | 'borderline' | 'not-helpful', rationale: '...' }
+ * One entry per workflow id. 20-30 entries is the right size to anchor the
+ * rubric without overfitting.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { scoreDetailedTemplate, type ScoreResult } from './criteria';
+import { fetchDetail, loadCachedCatalog, type CatalogEntry } from './fetch-templates';
+
+const CALIBRATION_PATH = path.resolve(__dirname, '../examples/_calibration.json');
+
+const VERDICT_TO_RANK: Record<string, number> = {
+	helpful: 2,
+	borderline: 1,
+	'not-helpful': 0,
+};
+
+interface CalibrationEntry {
+	id: number;
+	// 'TBD' is a placeholder for unlabelled entries; scoring skips them.
+	verdict: 'helpful' | 'borderline' | 'not-helpful' | 'TBD' | string;
+	rationale?: string;
+}
+
+interface CalibrationFile {
+	expert_tagged: CalibrationEntry[];
+}
+
+interface ScoredCalibrationEntry extends CalibrationEntry {
+	score: number;
+	breakdown: ScoreResult['breakdown'];
+	name: string;
+}
+
+function loadCalibration(): CalibrationFile {
+	if (!fs.existsSync(CALIBRATION_PATH)) {
+		throw new Error(
+			`Calibration file not found at ${CALIBRATION_PATH}. ` +
+				'Create it with shape { "expert_tagged": [{"id": N, "verdict": "helpful", "rationale": "..."}] }',
+		);
+	}
+	return JSON.parse(fs.readFileSync(CALIBRATION_PATH, 'utf-8')) as CalibrationFile;
+}
+
+/** Spearman rank correlation between two parallel arrays. Higher = stronger agreement. */
+export function spearmanCorrelation(xs: number[], ys: number[]): number {
+	if (xs.length !== ys.length) throw new Error('arrays must have equal length');
+	if (xs.length < 2) return 0;
+	const xRanks = ranksWithTies(xs);
+	const yRanks = ranksWithTies(ys);
+	const n = xs.length;
+	const meanX = xRanks.reduce((a, b) => a + b, 0) / n;
+	const meanY = yRanks.reduce((a, b) => a + b, 0) / n;
+	let num = 0;
+	let denX = 0;
+	let denY = 0;
+	for (let i = 0; i < n; i++) {
+		const dx = xRanks[i] - meanX;
+		const dy = yRanks[i] - meanY;
+		num += dx * dy;
+		denX += dx * dx;
+		denY += dy * dy;
+	}
+	if (denX === 0 || denY === 0) return 0;
+	return num / Math.sqrt(denX * denY);
+}
+
+/** Average rank for ties (standard for Spearman). */
+function ranksWithTies(values: number[]): number[] {
+	const indexed = values.map((v, i) => ({ v, i }));
+	indexed.sort((a, b) => a.v - b.v);
+	const ranks = new Array<number>(values.length);
+	let i = 0;
+	while (i < indexed.length) {
+		let j = i;
+		while (j + 1 < indexed.length && indexed[j + 1].v === indexed[i].v) j++;
+		const avgRank = (i + j) / 2 + 1;
+		for (let k = i; k <= j; k++) ranks[indexed[k].i] = avgRank;
+		i = j + 1;
+	}
+	return ranks;
+}
+
+async function scoreCalibration(
+	calib: CalibrationFile,
+	catalog: CatalogEntry[],
+): Promise<ScoredCalibrationEntry[]> {
+	const byId = new Map(catalog.map((c) => [c.id, c]));
+	const out: ScoredCalibrationEntry[] = [];
+	for (const entry of calib.expert_tagged) {
+		if (!Object.hasOwn(VERDICT_TO_RANK, entry.verdict)) {
+			console.warn(`  skipping ${entry.id}: verdict not yet labelled (got "${entry.verdict}")`);
+			continue;
+		}
+		const cat = byId.get(entry.id);
+		if (!cat) {
+			console.warn(`  skipping ${entry.id}: not in cached catalog`);
+			continue;
+		}
+		const detail = await fetchDetail(entry.id);
+		if (!detail) {
+			console.warn(`  skipping ${entry.id}: detail fetch failed`);
+			continue;
+		}
+		const result = scoreDetailedTemplate(cat, detail, []);
+		out.push({
+			...entry,
+			score: result.total,
+			breakdown: result.breakdown,
+			name: detail.data.attributes.name,
+		});
+	}
+	return out;
+}
+
+function printTopDisagreements(scored: ScoredCalibrationEntry[]): void {
+	const expertRanks = ranksWithTies(scored.map((s) => VERDICT_TO_RANK[s.verdict]));
+	const rubricRanks = ranksWithTies(scored.map((s) => s.score));
+	const disagreements = scored.map((s, i) => ({
+		entry: s,
+		expertRank: expertRanks[i],
+		rubricRank: rubricRanks[i],
+		gap: Math.abs(expertRanks[i] - rubricRanks[i]),
+	}));
+	disagreements.sort((a, b) => b.gap - a.gap);
+	console.log('\nTop disagreements (rubric rank vs expert rank):');
+	for (const d of disagreements.slice(0, 10)) {
+		const direction = d.rubricRank > d.expertRank ? 'overrated' : 'underrated';
+		console.log(
+			`  ${direction.padEnd(10)} gap=${d.gap.toFixed(1).padStart(4)} | ` +
+				`rubric=${d.rubricRank.toFixed(0).padStart(3)} expert=${d.expertRank.toFixed(0).padStart(3)} | ` +
+				`verdict=${d.entry.verdict.padEnd(11)} | ${d.entry.id} ${d.entry.name.slice(0, 50)}`,
+		);
+		if (d.entry.rationale) console.log(`             expert: "${d.entry.rationale}"`);
+	}
+}
+
+async function main() {
+	const calib = loadCalibration();
+	console.log(`Loaded ${calib.expert_tagged.length} calibration entries\n`);
+
+	const catalog = loadCachedCatalog();
+	const scored = await scoreCalibration(calib, catalog);
+
+	if (scored.length < 2) {
+		console.error('Not enough scored entries to compute correlation');
+		process.exit(1);
+	}
+
+	const expertScores = scored.map((s) => VERDICT_TO_RANK[s.verdict]);
+	const rubricScores = scored.map((s) => s.score);
+	const rho = spearmanCorrelation(expertScores, rubricScores);
+
+	console.log(`Calibration set size: ${scored.length}`);
+	console.log(`Spearman rank correlation: ${rho.toFixed(3)}`);
+	console.log(`Threshold (Phase 1 ships at): 0.700`);
+	console.log(`Status: ${rho >= 0.7 ? 'PASS' : 'TUNE WEIGHTS'}`);
+
+	printTopDisagreements(scored);
+}
+
+if (require.main === module) {
+	main().catch((error) => {
+		console.error(error);
+		process.exit(1);
+	});
+}
diff --git a/packages/@n8n/workflow-sdk/scripts/coverage.test.ts b/packages/@n8n/workflow-sdk/scripts/coverage.test.ts
new file mode 100644
index 00000000000..c2a9c7bf4d0
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/coverage.test.ts
@@ -0,0 +1,64 @@
+import { extractKeywords, matchPrompt } from './coverage';
+
+describe('coverage helpers', () => {
+	describe('extractKeywords', () => {
+		it('lowercases, splits on whitespace, drops stopwords and short tokens', () => {
+			const out = extractKeywords('Create a workflow that posts to Slack');
+			expect(out).toContain('posts');
+			expect(out).toContain('slack');
+			expect(out).not.toContain('the');
+			expect(out).not.toContain('a');
+			expect(out).not.toContain('to');
+		});
+
+		it('mixes in tag tokens', () => {
+			const out = extractKeywords('handle webhook submissions', ['google-sheets', 'multi-action']);
+			expect(out).toContain('webhook');
+			expect(out).toContain('google');
+			expect(out).toContain('sheets');
+			expect(out).toContain('multi');
+			expect(out).toContain('action');
+		});
+
+		it('dedupes repeated tokens', () => {
+			const out = extractKeywords('slack slack slack notify slack');
+			expect(out.filter((t) => t === 'slack').length).toBe(1);
+		});
+
+		it('removes punctuation', () => {
+			const out = extractKeywords('Notify the team in #general about it!');
+			expect(out).toContain('notify');
+			expect(out).toContain('team');
+			expect(out).toContain('general');
+		});
+	});
+
+	describe('matchPrompt', () => {
+		const wf = {
+			id: 1,
+			slug: 'gmail-to-slack',
+			name: 'Gmail to Slack notifier',
+			description: 'Forwards new Gmail messages to a Slack channel',
+			nodes: ['n8n-nodes-base.gmailTrigger', 'n8n-nodes-base.slack'],
+			tags: ['trigger:gmail', 'integration:slack'],
+			triggerType: 'gmail',
+			hasAI: false,
+		};
+
+		it('counts substring matches across name + description + nodes + tags', () => {
+			const result = matchPrompt(['gmail', 'slack', 'notify'], wf);
+			expect(result.matches).toBe(2); // gmail, slack
+			expect(result.matchedKeywords).toEqual(expect.arrayContaining(['gmail', 'slack']));
+		});
+
+		it('returns 0 matches when no keywords overlap', () => {
+			const result = matchPrompt(['airtable', 'discord'], wf);
+			expect(result.matches).toBe(0);
+		});
+
+		it('matches case-insensitively', () => {
+			const result = matchPrompt(['GMAIL', 'SLACK'], wf);
+			expect(result.matches).toBe(2);
+		});
+	});
+});
diff --git a/packages/@n8n/workflow-sdk/scripts/coverage.ts b/packages/@n8n/workflow-sdk/scripts/coverage.ts
new file mode 100644
index 00000000000..9dd403d88d3
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/coverage.ts
@@ -0,0 +1,324 @@
+/**
+ * Coverage check: do our curated templates cover the patterns real users ask for?
+ *
+ * Uses the existing instance-ai eval prompt corpus as a held-out test set.
+ * For each eval prompt, we extract a small keyword bag (filtered tokens from
+ * the prompt + the prompt's structural tags) and look for any manifest entry
+ * whose name+description+nodes+tags blob matches ≥2 keywords. Coverage = %
+ * of prompts with at least one match.
+ *
+ * This is intentionally a smoke test — keyword overlap will miss semantic
+ * matches and over-credit name overlap. The real signal lives in Phase 3
+ * telemetry on `Builder template read`. Coverage just stops us shipping a
+ * curated set with obvious gaps.
+ *
+ * Usage: pnpm criteria:coverage
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+const MANIFEST_PATH = path.resolve(__dirname, '../examples/manifest.json');
+const EVAL_DIR = path.resolve(__dirname, '../../instance-ai/evaluations/data/workflows');
+const REPORT_PATH = path.resolve(__dirname, '../examples/_coverage-report.json');
+
+const COVERAGE_TARGET = 0.7;
+const MIN_KEYWORD_MATCHES = 3;
+
+/**
+ * Words too generic to be useful matches. We want integration names, action
+ * verbs specific to a domain, and trigger types — not "send", "http", "node",
+ * "data", which appear in nearly every workflow.
+ */
+const STOPWORDS = new Set([
+	// Articles, conjunctions, prepositions
+	'a',
+	'an',
+	'and',
+	'are',
+	'as',
+	'at',
+	'be',
+	'but',
+	'by',
+	'for',
+	'from',
+	'has',
+	'have',
+	'i',
+	'if',
+	'in',
+	'is',
+	'it',
+	'its',
+	'me',
+	'my',
+	'of',
+	'on',
+	'or',
+	'so',
+	'the',
+	'their',
+	'them',
+	'this',
+	'that',
+	'to',
+	'was',
+	'we',
+	'were',
+	'will',
+	'with',
+	'into',
+	'over',
+	'under',
+	'they',
+	'one',
+	'two',
+	'three',
+	'been',
+	'being',
+	// Generic shape verbs
+	'create',
+	'use',
+	'used',
+	'using',
+	'should',
+	'can',
+	'configure',
+	'set',
+	'setup',
+	'send',
+	'sent',
+	'sends',
+	'sending',
+	'fetch',
+	'fetches',
+	'fetching',
+	'do',
+	'done',
+	'add',
+	'adds',
+	'adding',
+	'get',
+	'got',
+	'gets',
+	'getting',
+	'make',
+	'makes',
+	// Workflow-shape generic
+	'workflow',
+	'workflows',
+	'node',
+	'nodes',
+	'data',
+	'request',
+	'response',
+	'message',
+	'messages',
+	'item',
+	'items',
+	'value',
+	'values',
+	'field',
+	'fields',
+	'result',
+	'results',
+	'name',
+	'names',
+	'http',
+	'https',
+	'api',
+	'url',
+	'auth',
+	'options',
+	'parameters',
+	'credentials',
+	'credential',
+	'output',
+	'input',
+	'call',
+	'calls',
+	'com',
+	'org',
+	'net',
+	// Submission/contact tokens (too generic)
+	'submit',
+	'submitted',
+	'submission',
+	'submissions',
+	'submits',
+	'complete',
+	'completely',
+	'possible',
+	'help',
+	'please',
+	'thanks',
+	'don',
+	'all',
+	'every',
+	'each',
+	'when',
+	'then',
+	'how',
+	'what',
+	'about',
+	'via',
+	'out',
+	'ask',
+	// Single chars from contractions
+	't',
+	'm',
+	's',
+	're',
+	've',
+	'll',
+	'd',
+]);
+
+interface ManifestWorkflow {
+	id: number;
+	slug: string;
+	name: string;
+	description: string;
+	nodes: string[];
+	tags: string[];
+	triggerType: string;
+	hasAI: boolean;
+}
+
+interface ManifestFile {
+	workflows: ManifestWorkflow[];
+}
+
+interface EvalPrompt {
+	prompt: string;
+	complexity?: string;
+	tags?: string[];
+	triggerType?: string;
+}
+
+interface PromptCoverageResult {
+	prompt_file: string;
+	prompt: string;
+	keywords: string[];
+	matched: boolean;
+	top_match: { slug: string; matches: number; matched_keywords: string[] } | null;
+}
+
+export function extractKeywords(text: string, extraTags: string[] = []): string[] {
+	const tokens = text
+		.toLowerCase()
+		.replace(/[^a-z0-9\s-]/g, ' ')
+		.split(/\s+/)
+		.filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+	const tagTokens = extraTags
+		.flatMap((t) => t.toLowerCase().split(/[-\s]+/))
+		.filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+	const dedup = new Set<string>([...tokens, ...tagTokens]);
+	return Array.from(dedup);
+}
+
+export function matchPrompt(
+	keywords: string[],
+	workflow: ManifestWorkflow,
+): { matches: number; matchedKeywords: string[] } {
+	const haystack = [
+		workflow.name,
+		workflow.description,
+		workflow.nodes.join(' '),
+		workflow.tags.join(' '),
+		workflow.triggerType,
+	]
+		.join(' ')
+		.toLowerCase();
+
+	const matched: string[] = [];
+	for (const k of keywords) {
+		if (haystack.includes(k.toLowerCase())) matched.push(k);
+	}
+	return { matches: matched.length, matchedKeywords: matched };
+}
+
+function loadEvalPrompts(): Array<{ filename: string; data: EvalPrompt }> {
+	if (!fs.existsSync(EVAL_DIR)) {
+		throw new Error(`Eval directory not found at ${EVAL_DIR}`);
+	}
+	const files = fs.readdirSync(EVAL_DIR).filter((f) => f.endsWith('.json'));
+	return files.map((f) => ({
+		filename: f,
+		data: JSON.parse(fs.readFileSync(path.join(EVAL_DIR, f), 'utf-8')) as EvalPrompt,
+	}));
+}
+
+function loadManifest(): ManifestFile {
+	if (!fs.existsSync(MANIFEST_PATH)) {
+		throw new Error(
+			`Manifest not found at ${MANIFEST_PATH}. Run \`pnpm regenerate-examples\` first.`,
+		);
+	}
+	return JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf-8')) as ManifestFile;
+}
+
+function main() {
+	const manifest = loadManifest();
+	const prompts = loadEvalPrompts();
+
+	const results: PromptCoverageResult[] = [];
+	for (const { filename, data } of prompts) {
+		const keywords = extractKeywords(data.prompt, data.tags ?? []);
+		let bestMatch: { slug: string; matches: number; matched_keywords: string[] } | null = null;
+		for (const wf of manifest.workflows) {
+			const m = matchPrompt(keywords, wf);
+			if (m.matches >= MIN_KEYWORD_MATCHES) {
+				if (!bestMatch || m.matches > bestMatch.matches) {
+					bestMatch = { slug: wf.slug, matches: m.matches, matched_keywords: m.matchedKeywords };
+				}
+			}
+		}
+		results.push({
+			prompt_file: filename,
+			prompt: data.prompt.slice(0, 200),
+			keywords,
+			matched: bestMatch !== null,
+			top_match: bestMatch,
+		});
+	}
+
+	const covered = results.filter((r) => r.matched).length;
+	const ratio = covered / results.length;
+
+	const report = {
+		generatedAt: new Date().toISOString(),
+		total_prompts: results.length,
+		covered,
+		uncovered: results.length - covered,
+		coverage: Number(ratio.toFixed(3)),
+		target: COVERAGE_TARGET,
+		passed: ratio >= COVERAGE_TARGET,
+		results,
+	};
+
+	fs.writeFileSync(REPORT_PATH, JSON.stringify(report, null, 2));
+
+	console.log(
+		`Coverage: ${covered}/${results.length} (${(ratio * 100).toFixed(0)}%) — target ${(COVERAGE_TARGET * 100).toFixed(0)}%`,
+	);
+	console.log(`Status: ${ratio >= COVERAGE_TARGET ? 'PASS' : 'TUNE'}`);
+	console.log(`Wrote ${path.relative(process.cwd(), REPORT_PATH)}\n`);
+
+	const uncovered = results.filter((r) => !r.matched);
+	if (uncovered.length > 0) {
+		console.log('Uncovered prompts:');
+		for (const r of uncovered) {
+			console.log(`  - ${r.prompt_file}: "${r.prompt.slice(0, 80)}..."`);
+		}
+	}
+}
+
+if (require.main === module) {
+	try {
+		main();
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+}
diff --git a/packages/@n8n/workflow-sdk/scripts/create-examples-zip.ts b/packages/@n8n/workflow-sdk/scripts/create-examples-zip.ts
new file mode 100644
index 00000000000..85466d2316e
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/create-examples-zip.ts
@@ -0,0 +1,40 @@
+/**
+ * Packages all workflow JSON files from `examples/workflows/` into a single
+ * `examples/templates.zip` for committing. The manifest stays as a separate
+ * committed file — it is the source of truth and not zipped.
+ *
+ * Usage: pnpm create-examples-zip
+ */
+import AdmZip from 'adm-zip';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const EXAMPLES_DIR = path.resolve(__dirname, '..', 'examples');
+const WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+const ZIP_PATH = path.join(EXAMPLES_DIR, 'templates.zip');
+
+function createExamplesZip(): void {
+	if (!fs.existsSync(WORKFLOWS_DIR)) {
+		console.error(`Error: workflows dir not found at ${WORKFLOWS_DIR}`);
+		console.error('Run `pnpm regenerate-examples` first.');
+		process.exit(1);
+	}
+
+	const zip = new AdmZip();
+	const files = fs.readdirSync(WORKFLOWS_DIR).filter((f) => f.endsWith('.json'));
+
+	if (files.length === 0) {
+		console.error(`Error: no workflow JSON files found in ${WORKFLOWS_DIR}`);
+		process.exit(1);
+	}
+
+	for (const file of files) {
+		zip.addLocalFile(path.join(WORKFLOWS_DIR, file));
+	}
+
+	zip.writeZip(ZIP_PATH);
+	console.log(`Created: ${ZIP_PATH}`);
+	console.log(`Contents: ${files.length} workflows`);
+}
+
+createExamplesZip();
diff --git a/packages/@n8n/workflow-sdk/scripts/criteria.test.ts b/packages/@n8n/workflow-sdk/scripts/criteria.test.ts
new file mode 100644
index 00000000000..99854632fd7
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/criteria.test.ts
@@ -0,0 +1,452 @@
+import {
+	mechanicalGateCatalog,
+	mechanicalGateDetail,
+	tractionScore,
+	recencyScore,
+	coverageScore,
+	clarityScore,
+	densityScore,
+	bucketKey,
+	bucketKeyToString,
+	scoreCatalogEntry,
+	scoreDetailedTemplate,
+	hasAI,
+	WEIGHTS,
+	NODE_COUNT_MIN,
+	NODE_COUNT_MAX,
+	__test,
+	type BucketKey,
+} from './criteria';
+import type { CatalogEntry, DetailResponse } from './fetch-templates';
+
+// ---------------------------------------------------------------------------
+// Fixture builders
+// ---------------------------------------------------------------------------
+
+function makeCatalog(overrides: Partial<CatalogEntry> = {}): CatalogEntry {
+	return {
+		id: 1,
+		name: 'Test Workflow',
+		totalViews: 1000,
+		createdAt: new Date().toISOString(),
+		user: { username: 'someone', verified: true },
+		purchaseUrl: null,
+		nodes: Array.from({ length: 5 }, (_, i) => ({ name: `node-${i}` })),
+		...overrides,
+	};
+}
+
+function makeDetail(
+	opts: {
+		nodes?: Array<Record<string, unknown>>;
+		connections?: Record<string, unknown>;
+		views?: number;
+		recentViews?: number;
+		updatedAt?: string;
+		status?: string;
+	} = {},
+): DetailResponse {
+	return {
+		data: {
+			id: 1,
+			attributes: {
+				name: 'Detail',
+				description: '',
+				workflow: {
+					nodes: opts.nodes ?? [
+						{ id: 't', name: 'Schedule Trigger', type: 'n8n-nodes-base.scheduleTrigger' },
+						{ id: 'a', name: 'My Slack Post', type: 'n8n-nodes-base.slack' },
+						{ id: 'b', name: 'Format Output', type: 'n8n-nodes-base.set' },
+					],
+					connections: opts.connections ?? {},
+				},
+				createdAt: '2024-01-01T00:00:00Z',
+				updatedAt: opts.updatedAt ?? new Date().toISOString(),
+				views: opts.views ?? 1000,
+				recentViews: opts.recentViews ?? 5,
+				hidden: false,
+				username: 'someone',
+				status: opts.status ?? 'published',
+				price: null,
+				difficulty: null,
+				readyToDemo: null,
+			},
+		},
+		meta: {},
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Mechanical gate
+// ---------------------------------------------------------------------------
+
+describe('mechanicalGateCatalog', () => {
+	it('passes a typical free verified workflow', () => {
+		expect(mechanicalGateCatalog(makeCatalog())).toEqual({ ok: true });
+	});
+
+	it('rejects paid via purchaseUrl', () => {
+		const r = mechanicalGateCatalog(makeCatalog({ purchaseUrl: 'https://example.com/buy' }));
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects paid via positive price', () => {
+		const r = mechanicalGateCatalog(makeCatalog({ price: 5 }));
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects unverified author', () => {
+		const r = mechanicalGateCatalog(makeCatalog({ user: { username: 'rando', verified: false } }));
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects oversized workflow at the catalog stage', () => {
+		const big = makeCatalog({
+			nodes: Array.from({ length: NODE_COUNT_MAX + 5 }, (_, i) => ({ name: `n${i}` })),
+		});
+		const r = mechanicalGateCatalog(big);
+		expect(r.ok).toBe(false);
+	});
+
+	it('does NOT enforce lower bound at catalog stage (list nodes are sparse)', () => {
+		const small = makeCatalog({ nodes: [{ name: 'x' }] });
+		expect(mechanicalGateCatalog(small)).toEqual({ ok: true });
+	});
+});
+
+describe('mechanicalGateDetail', () => {
+	it('passes a typical workflow with trigger', () => {
+		expect(mechanicalGateDetail(makeDetail())).toEqual({ ok: true });
+	});
+
+	it('rejects unpublished status', () => {
+		const r = mechanicalGateDetail(makeDetail({ status: 'draft' }));
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects too-small node count', () => {
+		const r = mechanicalGateDetail(
+			makeDetail({
+				nodes: Array.from({ length: NODE_COUNT_MIN - 1 }, (_, i) => ({
+					id: String(i),
+					type: 'n8n-nodes-base.set',
+				})),
+			}),
+		);
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects too-large node count', () => {
+		const r = mechanicalGateDetail(
+			makeDetail({
+				nodes: Array.from({ length: NODE_COUNT_MAX + 1 }, (_, i) => ({
+					id: String(i),
+					type: 'n8n-nodes-base.set',
+				})),
+			}),
+		);
+		expect(r.ok).toBe(false);
+	});
+
+	it('rejects when no trigger present', () => {
+		const r = mechanicalGateDetail(
+			makeDetail({
+				nodes: [
+					{ id: '1', type: 'n8n-nodes-base.set' },
+					{ id: '2', type: 'n8n-nodes-base.slack' },
+					{ id: '3', type: 'n8n-nodes-base.gmail' },
+				],
+			}),
+		);
+		expect(r.ok).toBe(false);
+		if (!r.ok) expect(r.reason).toContain('trigger');
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Per-dimension scorers
+// ---------------------------------------------------------------------------
+
+describe('tractionScore', () => {
+	it('is monotonic in views', () => {
+		expect(tractionScore(10, 0)).toBeLessThan(tractionScore(1000, 0));
+		expect(tractionScore(1000, 0)).toBeLessThan(tractionScore(100000, 0));
+	});
+
+	it('is bounded in [0, 1]', () => {
+		expect(tractionScore(0, 0)).toBe(0);
+		expect(tractionScore(10_000_000, 10_000_000)).toBeLessThanOrEqual(1);
+	});
+});
+
+describe('recencyScore', () => {
+	const now = new Date('2026-05-07T00:00:00Z').getTime();
+
+	it('is 1.0 for fresh workflows (≤90d)', () => {
+		const updatedAt = new Date(now - 30 * 24 * 3600 * 1000).toISOString();
+		expect(recencyScore(updatedAt, now)).toBe(1);
+	});
+
+	it('is 0 for workflows older than 2y', () => {
+		const updatedAt = new Date(now - 1000 * 24 * 3600 * 1000).toISOString();
+		expect(recencyScore(updatedAt, now)).toBe(0);
+	});
+
+	it('decays linearly between 90d and 2y', () => {
+		const oneYearAgo = new Date(now - 365 * 24 * 3600 * 1000).toISOString();
+		const score = recencyScore(oneYearAgo, now);
+		expect(score).toBeGreaterThan(0);
+		expect(score).toBeLessThan(1);
+	});
+});
+
+describe('coverageScore', () => {
+	const bucket: BucketKey = {
+		triggerType: 'webhook',
+		primaryIntegration: 'slack',
+		hasAI: false,
+		controlFlowKind: 'linear',
+	};
+
+	it('is 1.0 for an empty running set', () => {
+		expect(coverageScore(bucket, [])).toBe(1);
+	});
+
+	it('halves with each duplicate bucket', () => {
+		expect(coverageScore(bucket, [bucket])).toBeCloseTo(0.5);
+		expect(coverageScore(bucket, [bucket, bucket])).toBeCloseTo(1 / 3);
+	});
+
+	it('is unaffected by other buckets', () => {
+		const other: BucketKey = { ...bucket, triggerType: 'schedule' };
+		expect(coverageScore(bucket, [other, other, other])).toBe(1);
+	});
+});
+
+describe('clarityScore', () => {
+	it('rewards named nodes, sticky notes, and distinct types', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 'sticky', type: 'n8n-nodes-base.stickyNote', name: 'Doc' },
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger', name: 'Daily 9am' },
+				{ id: 'a', type: 'n8n-nodes-base.slack', name: 'Post update' },
+				{ id: 'b', type: 'n8n-nodes-base.gmail', name: 'Send digest' },
+			],
+		});
+		// All real nodes named, sticky present, ≥3 distinct types → 0.4 + 0.3 + 0.3 = 1.0
+		expect(clarityScore(detail)).toBeCloseTo(1.0);
+	});
+
+	it('penalises default-named workflows', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger', name: 'Schedule Trigger' },
+				{ id: 's1', type: 'n8n-nodes-base.set', name: 'Edit Fields' },
+				{ id: 's2', type: 'n8n-nodes-base.set', name: 'Edit Fields1' },
+			],
+		});
+		// All default-named, no sticky, only 2 distinct types
+		expect(clarityScore(detail)).toBeLessThan(0.4);
+	});
+});
+
+describe('densityScore', () => {
+	it('is 1.0 when every node is a different type', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger' },
+				{ id: 'a', type: 'n8n-nodes-base.slack' },
+				{ id: 'b', type: 'n8n-nodes-base.gmail' },
+			],
+		});
+		expect(densityScore(detail)).toBe(1);
+	});
+
+	it('is low when many nodes share types', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger' },
+				{ id: '1', type: 'n8n-nodes-base.set' },
+				{ id: '2', type: 'n8n-nodes-base.set' },
+				{ id: '3', type: 'n8n-nodes-base.set' },
+			],
+		});
+		// 2 distinct / 4 nodes = 0.5
+		expect(densityScore(detail)).toBeCloseTo(0.5);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Bucket key
+// ---------------------------------------------------------------------------
+
+describe('bucketKey', () => {
+	it('classifies a webhook → slack workflow without AI', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.webhook' },
+				{ id: 'a', type: 'n8n-nodes-base.slack' },
+				{ id: 'b', type: 'n8n-nodes-base.set' },
+			],
+		});
+		const key = bucketKey(detail);
+		expect(key.triggerType).toBe('webhook');
+		expect(key.primaryIntegration).toBe('slack');
+		expect(key.hasAI).toBe(false);
+		expect(key.controlFlowKind).toBe('linear');
+	});
+
+	it('classifies AI agent workflows', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: '@n8n/n8n-nodes-langchain.chatTrigger' },
+				{ id: 'm', type: '@n8n/n8n-nodes-langchain.lmChatOpenAi' },
+				{ id: 'a', type: '@n8n/n8n-nodes-langchain.agent' },
+			],
+		});
+		const key = bucketKey(detail);
+		expect(key.triggerType).toBe('chatTrigger');
+		expect(key.hasAI).toBe(true);
+	});
+
+	it('detects branching control flow', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger' },
+				{ id: 'i', type: 'n8n-nodes-base.if' },
+				{ id: 'a', type: 'n8n-nodes-base.slack' },
+				{ id: 'b', type: 'n8n-nodes-base.gmail' },
+			],
+			connections: {},
+		});
+		expect(bucketKey(detail).controlFlowKind).toBe('branching');
+	});
+
+	it('detects loop control flow', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger' },
+				{ id: 'l', type: 'n8n-nodes-base.splitInBatches' },
+				{ id: 'a', type: 'n8n-nodes-base.slack' },
+			],
+		});
+		expect(bucketKey(detail).controlFlowKind).toBe('loop');
+	});
+
+	it('detects parallel control flow from connections fan-out', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger', name: 'Trigger' },
+				{ id: 'a', type: 'n8n-nodes-base.slack', name: 'A' },
+				{ id: 'b', type: 'n8n-nodes-base.gmail', name: 'B' },
+			],
+			connections: {
+				Trigger: {
+					main: [
+						[
+							{ node: 'A', type: 'main', index: 0 },
+							{ node: 'B', type: 'main', index: 0 },
+						],
+					],
+				},
+			},
+		});
+		expect(bucketKey(detail).controlFlowKind).toBe('parallel');
+	});
+});
+
+describe('bucketKeyToString', () => {
+	it('produces stable keys', () => {
+		const a: BucketKey = {
+			triggerType: 'webhook',
+			primaryIntegration: 'slack',
+			hasAI: false,
+			controlFlowKind: 'linear',
+		};
+		expect(bucketKeyToString(a)).toBe('webhook|slack|noai|linear');
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Composition
+// ---------------------------------------------------------------------------
+
+describe('scoreCatalogEntry', () => {
+	it('uses traction + recency only (other dims zero)', () => {
+		const entry = makeCatalog({ totalViews: 10000, createdAt: new Date().toISOString() });
+		const result = scoreCatalogEntry(entry);
+		expect(result.breakdown.coverage).toBe(0);
+		expect(result.breakdown.clarity).toBe(0);
+		expect(result.breakdown.density).toBe(0);
+		expect(result.total).toBeGreaterThan(0);
+	});
+});
+
+describe('scoreDetailedTemplate', () => {
+	it('combines all weighted dimensions', () => {
+		const entry = makeCatalog();
+		const detail = makeDetail();
+		const result = scoreDetailedTemplate(entry, detail, []);
+		expect(result.breakdown.traction).toBeGreaterThan(0);
+		expect(result.breakdown.recency).toBeGreaterThan(0);
+		expect(result.breakdown.coverage).toBe(1); // empty running set
+		expect(result.total).toBeGreaterThan(0);
+	});
+
+	it('drops coverage as duplicates accumulate', () => {
+		const entry = makeCatalog();
+		const detail = makeDetail();
+		const bucket = bucketKey(detail);
+		const empty = scoreDetailedTemplate(entry, detail, []);
+		const oneDup = scoreDetailedTemplate(entry, detail, [bucket]);
+		expect(empty.total).toBeGreaterThan(oneDup.total);
+	});
+
+	it('aiAgent dimension contributes 0 to total because weight is 0', () => {
+		const entry = makeCatalog();
+		const aiDetail = makeDetail({
+			nodes: [
+				{ id: 't', type: '@n8n/n8n-nodes-langchain.chatTrigger' },
+				{ id: 'a', type: '@n8n/n8n-nodes-langchain.agent' },
+				{ id: 'm', type: '@n8n/n8n-nodes-langchain.memoryBufferWindow' },
+				{ id: 'l', type: '@n8n/n8n-nodes-langchain.lmChatOpenAi' },
+			],
+		});
+		const noAiDetail = makeDetail();
+		const aiResult = scoreDetailedTemplate(entry, aiDetail, []);
+		const noAiResult = scoreDetailedTemplate(entry, noAiDetail, []);
+		// AI signal is computed but the weight is 0 for now
+		expect(aiResult.breakdown.aiAgent).toBeGreaterThan(0);
+		expect(noAiResult.breakdown.aiAgent).toBe(0);
+		expect(WEIGHTS.aiAgent).toBe(0);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Tagged internals (compact tests, low-risk)
+// ---------------------------------------------------------------------------
+
+describe('internal helpers', () => {
+	it('vendorOf strips type prefix', () => {
+		expect(__test.vendorOf('n8n-nodes-base.googleSheets')).toBe('googleSheets');
+		expect(__test.vendorOf('@n8n/n8n-nodes-langchain.openAi')).toBe('langchain');
+	});
+
+	it('isDefaultName flags repeated default-style names', () => {
+		expect(__test.isDefaultName({ name: 'Edit Fields', type: 'n8n-nodes-base.set' })).toBe(true);
+		expect(__test.isDefaultName({ name: 'Edit Fields1', type: 'n8n-nodes-base.set' })).toBe(true);
+		expect(__test.isDefaultName({ name: 'My Slack Post', type: 'n8n-nodes-base.slack' })).toBe(
+			false,
+		);
+	});
+
+	it('hasAI is true for any langchain-prefixed node', () => {
+		const detail = makeDetail({
+			nodes: [
+				{ id: 't', type: 'n8n-nodes-base.scheduleTrigger' },
+				{ id: 'a', type: '@n8n/n8n-nodes-langchain.agent' },
+			],
+		});
+		expect(hasAI(detail)).toBe(true);
+	});
+});
diff --git a/packages/@n8n/workflow-sdk/scripts/criteria.ts b/packages/@n8n/workflow-sdk/scripts/criteria.ts
new file mode 100644
index 00000000000..17972ee28a7
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/criteria.ts
@@ -0,0 +1,398 @@
+/**
+ * Helpfulness rubric for template curation.
+ *
+ * Tunable knobs are at the top of the file. Documentation lives in
+ * `docs/template-criteria.md`. The score breakdown is preserved per template
+ * so manifest entries are reviewable: anyone can see why a template ranked
+ * where it did.
+ *
+ * Two scoring stages:
+ *   - `scoreCatalogEntry()` — runs against cheap list metadata, used to pick
+ *     the top-K candidates worth fetching detail for.
+ *   - `scoreDetailedTemplate()` — runs against full detail JSON, used to
+ *     pick the final manifest set with full diversity bucketing.
+ */
+import type { CatalogEntry, DetailResponse } from './fetch-templates';
+
+// ---------------------------------------------------------------------------
+// Tunable weights
+// ---------------------------------------------------------------------------
+
+export const WEIGHTS = {
+	traction: 20,
+	recency: 20,
+	coverage: 35,
+	aiAgent: 0, // folded into bucket key; lift if telemetry shows under-use
+	clarity: 15,
+	density: 5,
+} as const;
+
+export const NODE_COUNT_MIN = 3;
+export const NODE_COUNT_MAX = 40;
+export const RECENCY_FRESH_DAYS = 90;
+export const RECENCY_STALE_DAYS = 730; // 2 years
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type GateResult = { ok: true } | { ok: false; reason: string };
+
+export interface RubricBreakdown {
+	traction: number;
+	recency: number;
+	coverage: number;
+	aiAgent: number;
+	clarity: number;
+	density: number;
+}
+
+export interface ScoreResult {
+	total: number;
+	breakdown: RubricBreakdown;
+}
+
+export type TriggerType =
+	| 'webhook'
+	| 'schedule'
+	| 'chatTrigger'
+	| 'formTrigger'
+	| 'manual'
+	| 'telegram'
+	| 'gmail'
+	| 'other';
+
+export type ControlFlowKind = 'linear' | 'branching' | 'loop' | 'parallel';
+
+export interface BucketKey {
+	triggerType: TriggerType;
+	primaryIntegration: string;
+	hasAI: boolean;
+	controlFlowKind: ControlFlowKind;
+}
+
+// ---------------------------------------------------------------------------
+// Mechanical gate
+// ---------------------------------------------------------------------------
+
+/** Catalog-stage gate. List-only metadata. */
+export function mechanicalGateCatalog(entry: CatalogEntry): GateResult {
+	if (entry.purchaseUrl !== null) return { ok: false, reason: 'paid (purchaseUrl set)' };
+	if (entry.price !== null && entry.price !== undefined && entry.price > 0) {
+		return { ok: false, reason: `paid (price=${entry.price})` };
+	}
+	if (!entry.user?.verified) return { ok: false, reason: 'unverified author' };
+	const listNodeCount = entry.nodes?.length ?? 0;
+	// List nodes is sparse; only enforce upper bound here. Lower bound rechecked at detail.
+	if (listNodeCount > NODE_COUNT_MAX) {
+		return { ok: false, reason: `too large (list reports ${listNodeCount} nodes)` };
+	}
+	return { ok: true };
+}
+
+/** Detail-stage gate. Real workflow JSON. */
+export function mechanicalGateDetail(detail: DetailResponse): GateResult {
+	const attrs = detail.data.attributes;
+	if (attrs.status !== 'published') return { ok: false, reason: `status=${attrs.status}` };
+	const realNodeCount = attrs.workflow.nodes?.length ?? 0;
+	if (realNodeCount < NODE_COUNT_MIN || realNodeCount > NODE_COUNT_MAX) {
+		return {
+			ok: false,
+			reason: `nodeCount ${realNodeCount} outside [${NODE_COUNT_MIN}, ${NODE_COUNT_MAX}]`,
+		};
+	}
+	if (findTriggerNode(detail) === null) {
+		return { ok: false, reason: 'no trigger node' };
+	}
+	return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Per-dimension scorers
+// ---------------------------------------------------------------------------
+
+/** Traction: log-scaled views; mixes total + recent so freshness matters too. */
+export function tractionScore(totalViews: number, recentViews: number): number {
+	const total = Math.log10(Math.max(0, totalViews) + 1);
+	const recent = Math.log10(Math.max(0, recentViews) + 1);
+	// Normalise to ~[0, 1]: log10(1M) = 6, log10(1K) = 3 → cap divisor at 8
+	return Math.min(1, (total + recent) / 8);
+}
+
+/** Recency: 1.0 if updated within N days, 0.0 once stale, linear in between. */
+export function recencyScore(updatedAt: string, now: number = Date.now()): number {
+	const ageMs = now - new Date(updatedAt).getTime();
+	const ageDays = ageMs / (24 * 3600 * 1000);
+	if (ageDays <= RECENCY_FRESH_DAYS) return 1;
+	if (ageDays >= RECENCY_STALE_DAYS) return 0;
+	return 1 - (ageDays - RECENCY_FRESH_DAYS) / (RECENCY_STALE_DAYS - RECENCY_FRESH_DAYS);
+}
+
+/** Marginal coverage: how rare is this template's bucket in the running set? */
+export function coverageScore(bucket: BucketKey, runningSet: BucketKey[]): number {
+	const key = bucketKeyToString(bucket);
+	const count = runningSet.reduce(
+		(n, existing) => (bucketKeyToString(existing) === key ? n + 1 : n),
+		0,
+	);
+	return 1 / (1 + count);
+}
+
+/** AI-agent presence (currently weighted 0; signal still computed for telemetry). */
+export function aiAgentScore(detail: DetailResponse): number {
+	if (!hasAI(detail)) return 0;
+	if (hasSubnodePattern(detail)) return 1;
+	return 0.6;
+}
+
+/** Structural clarity: signals of authoring care. */
+export function clarityScore(detail: DetailResponse): number {
+	const nodes = detail.data.attributes.workflow.nodes ?? [];
+	let score = 0;
+
+	const realNodes = nodes.filter((n) => !isStickyNote(n));
+	const namedRatio =
+		realNodes.length === 0
+			? 0
+			: realNodes.filter((n) => !isDefaultName(n)).length / realNodes.length;
+	if (namedRatio >= 0.5) score += 0.4;
+
+	const stickyCount = nodes.filter(isStickyNote).length;
+	if (stickyCount >= 1) score += 0.3;
+
+	const distinctTypes = new Set(realNodes.map((n) => String(n.type ?? ''))).size;
+	if (distinctTypes >= 3) score += 0.3;
+
+	return score;
+}
+
+/** Pedagogical density: distinct node types relative to total. */
+export function densityScore(detail: DetailResponse): number {
+	const nodes = detail.data.attributes.workflow.nodes ?? [];
+	const realNodes = nodes.filter((n) => !isStickyNote(n));
+	if (realNodes.length === 0) return 0;
+	const distinctTypes = new Set(realNodes.map((n) => String(n.type ?? ''))).size;
+	return Math.min(1, distinctTypes / realNodes.length);
+}
+
+// ---------------------------------------------------------------------------
+// Public scorers (compose per-dimension scores into totals)
+// ---------------------------------------------------------------------------
+
+/** Catalog-stage score. Does not include coverage, clarity, density (need detail). */
+export function scoreCatalogEntry(entry: CatalogEntry): ScoreResult {
+	const traction = tractionScore(entry.totalViews ?? 0, 0); // recentViews unavailable here
+	// List endpoint only returns createdAt; detail stage rescores with updatedAt.
+	const recency = recencyScore(entry.createdAt);
+	const breakdown: RubricBreakdown = {
+		traction,
+		recency,
+		coverage: 0,
+		aiAgent: 0,
+		clarity: 0,
+		density: 0,
+	};
+	const total = WEIGHTS.traction * traction + WEIGHTS.recency * recency;
+	return { total, breakdown };
+}
+
+/** Detail-stage score. Full rubric. `runningSet` lets coverage update as picks accumulate. */
+export function scoreDetailedTemplate(
+	entry: CatalogEntry,
+	detail: DetailResponse,
+	runningSet: BucketKey[],
+): ScoreResult {
+	const attrs = detail.data.attributes;
+	const traction = tractionScore(attrs.views ?? 0, attrs.recentViews ?? 0);
+	const recency = recencyScore(attrs.updatedAt);
+	const bucket = bucketKey(detail);
+	const coverage = coverageScore(bucket, runningSet);
+	const aiAgent = aiAgentScore(detail);
+	const clarity = clarityScore(detail);
+	const density = densityScore(detail);
+
+	const breakdown: RubricBreakdown = { traction, recency, coverage, aiAgent, clarity, density };
+	const total =
+		WEIGHTS.traction * traction +
+		WEIGHTS.recency * recency +
+		WEIGHTS.coverage * coverage +
+		WEIGHTS.aiAgent * aiAgent +
+		WEIGHTS.clarity * clarity +
+		WEIGHTS.density * density;
+
+	return { total, breakdown };
+}
+
+// ---------------------------------------------------------------------------
+// Bucket key derivation
+// ---------------------------------------------------------------------------
+
+export function bucketKey(detail: DetailResponse): BucketKey {
+	return {
+		triggerType: classifyTrigger(detail),
+		primaryIntegration: classifyIntegration(detail),
+		hasAI: hasAI(detail),
+		controlFlowKind: classifyControlFlow(detail),
+	};
+}
+
+export function bucketKeyToString(b: BucketKey): string {
+	return `${b.triggerType}|${b.primaryIntegration}|${b.hasAI ? 'ai' : 'noai'}|${b.controlFlowKind}`;
+}
+
+function classifyTrigger(detail: DetailResponse): TriggerType {
+	const node = findTriggerNode(detail);
+	if (!node) return 'other';
+	const type = String(node.type ?? '');
+	if (type.includes('chatTrigger')) return 'chatTrigger';
+	if (type.includes('webhook')) return 'webhook';
+	if (type.includes('scheduleTrigger') || type.includes('cron')) return 'schedule';
+	if (type.includes('formTrigger')) return 'formTrigger';
+	if (type.includes('manualTrigger')) return 'manual';
+	if (type.includes('telegram')) return 'telegram';
+	if (type.includes('gmail')) return 'gmail';
+	return 'other';
+}
+
+function classifyIntegration(detail: DetailResponse): string {
+	const counts = new Map<string, number>();
+	for (const node of detail.data.attributes.workflow.nodes ?? []) {
+		const t = String(node.type ?? '');
+		if (!t) continue;
+		// Skip triggers and meta nodes from primary integration calc
+		if (isTriggerType(t) || isMetaType(t)) continue;
+		const integ = vendorOf(t);
+		counts.set(integ, (counts.get(integ) ?? 0) + 1);
+	}
+	if (counts.size === 0) return 'none';
+	const sorted = Array.from(counts.entries()).sort((a, b) => b[1] - a[1]);
+	return sorted[0][0];
+}
+
+function classifyControlFlow(detail: DetailResponse): ControlFlowKind {
+	const nodes = detail.data.attributes.workflow.nodes ?? [];
+	const types = nodes.map((n) => String(n.type ?? ''));
+	if (types.some((t) => t.includes('splitInBatches'))) return 'loop';
+	if (types.some((t) => t.includes('.if') || t.includes('.switch'))) return 'branching';
+	const connections = detail.data.attributes.workflow.connections ?? {};
+	for (const fromNode of Object.values(connections)) {
+		const main = (fromNode as { main?: unknown[][] }).main;
+		if (Array.isArray(main) && main.length > 1) return 'parallel';
+		if (Array.isArray(main) && main[0] && Array.isArray(main[0]) && main[0].length > 1) {
+			return 'parallel';
+		}
+	}
+	return 'linear';
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findTriggerNode(detail: DetailResponse): Record<string, unknown> | null {
+	for (const node of detail.data.attributes.workflow.nodes ?? []) {
+		const type = String(node.type ?? '');
+		if (isTriggerType(type)) return node;
+	}
+	return null;
+}
+
+function isTriggerType(type: string): boolean {
+	return (
+		type.includes('Trigger') ||
+		type.endsWith('.webhook') ||
+		type.endsWith('.cron') ||
+		type.endsWith('.manualTrigger')
+	);
+}
+
+function isMetaType(type: string): boolean {
+	return type.endsWith('.stickyNote') || type.endsWith('.noOp');
+}
+
+function isStickyNote(node: Record<string, unknown>): boolean {
+	return String(node.type ?? '').endsWith('.stickyNote');
+}
+
+/**
+ * Names n8n auto-assigns when a node is added. Numeric suffixes (`Edit Fields1`,
+ * `HTTP Request2`) are stripped before lookup. Curated; extend as new common
+ * defaults surface.
+ */
+const KNOWN_DEFAULT_NAMES = new Set([
+	'Edit Fields',
+	'HTTP Request',
+	'Schedule Trigger',
+	'Manual Trigger',
+	'Webhook',
+	'Form Trigger',
+	'Email Trigger (IMAP)',
+	'When chat message received',
+	'Sticky Note',
+	'AI Agent',
+	'Basic LLM Chain',
+	'OpenAI Chat Model',
+	'Simple Memory',
+	'Window Buffer Memory',
+]);
+
+/**
+ * Heuristic: is this node's name auto-generated by n8n rather than authored?
+ *
+ * Two flavours of default:
+ *   - A single Title-Case word optionally followed by a digit: `Set`, `Code`,
+ *     `Slack2`, `Gmail`. These are generated from the node's display name.
+ *   - A known multi-word default in `KNOWN_DEFAULT_NAMES`.
+ *
+ * Custom names typically break out of these patterns by adding lowercase words
+ * (`Post daily update`), specific personalisation (`My Slack post`), or by
+ * being longer than the canonical default form.
+ */
+function isDefaultName(node: Record<string, unknown>): boolean {
+	const name = String(node.name ?? '').trim();
+	if (!name) return true;
+	const stripped = name.replace(/\d+$/, '').trim();
+	if (KNOWN_DEFAULT_NAMES.has(stripped)) return true;
+	// Single Title-Case word: 'Set', 'Slack', 'Gmail'
+	if (/^[A-Z][a-zA-Z]*$/.test(stripped)) return true;
+	return false;
+}
+
+function vendorOf(type: string): string {
+	// '@n8n/n8n-nodes-langchain.openAi' → 'langchain'
+	// 'n8n-nodes-base.googleSheets' → 'googleSheets'
+	if (type.startsWith('@n8n/n8n-nodes-langchain.')) return 'langchain';
+	const dot = type.lastIndexOf('.');
+	if (dot < 0) return type;
+	return type.slice(dot + 1);
+}
+
+export function hasAI(detail: DetailResponse): boolean {
+	for (const node of detail.data.attributes.workflow.nodes ?? []) {
+		const t = String(node.type ?? '');
+		if (t.startsWith('@n8n/n8n-nodes-langchain.')) return true;
+		if (t.includes('openAi') || t.includes('anthropic')) return true;
+	}
+	return false;
+}
+
+function hasSubnodePattern(detail: DetailResponse): boolean {
+	const types = (detail.data.attributes.workflow.nodes ?? []).map((n) => String(n.type ?? ''));
+	const hasAgent = types.some((t) => t.endsWith('.agent'));
+	const hasMemory = types.some((t) => t.includes('memory'));
+	const hasTool = types.some((t) => t.includes('tool'));
+	return hasAgent && (hasMemory || hasTool);
+}
+
+// ---------------------------------------------------------------------------
+// Exports for tests
+// ---------------------------------------------------------------------------
+
+export const __test = {
+	classifyTrigger,
+	classifyIntegration,
+	classifyControlFlow,
+	findTriggerNode,
+	isDefaultName,
+	vendorOf,
+};
diff --git a/packages/@n8n/workflow-sdk/scripts/extract-workflows.ts b/packages/@n8n/workflow-sdk/scripts/extract-workflows.ts
index 0864ec90d6f..5db42a52e59 100644
--- a/packages/@n8n/workflow-sdk/scripts/extract-workflows.ts
+++ b/packages/@n8n/workflow-sdk/scripts/extract-workflows.ts
@@ -1,8 +1,11 @@
 /**
- * Extract Test Workflows from Zip
+ * Extract Test Workflows from Zips
  *
- * Extracts workflow JSON files from the committed zip file for testing.
- * This runs automatically via `pretest` hook before running tests.
+ * Extracts workflow JSON files from committed zip files for testing:
+ *   - test-fixtures/real-workflows/public_published_templates.zip → test-fixtures/real-workflows/
+ *   - examples/templates.zip → examples/workflows/ (used by examples-roundtrip test)
+ *
+ * Runs automatically via Jest's globalSetup (see scripts/jest-global-setup.ts).
  *
  * Usage:
  *   npx tsx scripts/extract-workflows.ts
@@ -13,35 +16,51 @@ import * as path from 'path';
 import AdmZip from 'adm-zip';
 
 const FIXTURES_DIR = path.resolve(__dirname, '../test-fixtures/real-workflows');
-const ZIP_FILE = path.join(FIXTURES_DIR, 'public_published_templates.zip');
+const FIXTURES_ZIP = path.join(FIXTURES_DIR, 'public_published_templates.zip');
 
-function main() {
-	if (!fs.existsSync(ZIP_FILE)) {
-		console.log('No zip file found, skipping extraction');
+const EXAMPLES_DIR = path.resolve(__dirname, '../examples');
+const EXAMPLES_ZIP = path.join(EXAMPLES_DIR, 'templates.zip');
+const EXAMPLES_WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+
+function extractZip(zipPath: string, outputDir: string, label: string) {
+	if (!fs.existsSync(zipPath)) {
+		console.log(`No ${label} zip found at ${zipPath}, skipping extraction`);
 		return;
 	}
 
-	// Check if extraction is needed by looking for any .json file
-	const existingFiles = fs.readdirSync(FIXTURES_DIR).filter((f) => f.endsWith('.json'));
+	fs.mkdirSync(outputDir, { recursive: true });
+
+	const existingFiles = fs.readdirSync(outputDir).filter((f) => f.endsWith('.json'));
 	if (existingFiles.length > 0) {
-		console.log(`Found ${existingFiles.length} workflow files, skipping extraction`);
+		console.log(`Found ${existingFiles.length} ${label} files, skipping extraction`);
 		return;
 	}
 
-	console.log('Extracting workflows from zip...');
-	const zip = new AdmZip(ZIP_FILE);
+	console.log(`Extracting ${label} from zip...`);
+	const zip = new AdmZip(zipPath);
 	const entries = zip.getEntries();
+	const resolvedOutputDir = path.resolve(outputDir);
 
 	let count = 0;
 	for (const entry of entries) {
-		if (entry.entryName.endsWith('.json')) {
-			const outputPath = path.join(FIXTURES_DIR, entry.entryName);
-			fs.writeFileSync(outputPath, entry.getData());
-			count++;
+		if (!entry.entryName.endsWith('.json')) continue;
+		const outputPath = path.resolve(outputDir, entry.entryName);
+		if (outputPath !== resolvedOutputDir && !outputPath.startsWith(resolvedOutputDir + path.sep)) {
+			console.warn(`Skipping out-of-bounds entry: ${entry.entryName}`);
+			continue;
 		}
+		fs.writeFileSync(outputPath, entry.getData());
+		count++;
 	}
 
-	console.log(`Extracted ${count} workflow files`);
+	console.log(`Extracted ${count} ${label} files`);
 }
 
-main();
+export function extractAllWorkflows() {
+	extractZip(FIXTURES_ZIP, FIXTURES_DIR, 'test-fixtures workflows');
+	extractZip(EXAMPLES_ZIP, EXAMPLES_WORKFLOWS_DIR, 'examples workflows');
+}
+
+if (require.main === module) {
+	extractAllWorkflows();
+}
diff --git a/packages/@n8n/workflow-sdk/scripts/fetch-templates.ts b/packages/@n8n/workflow-sdk/scripts/fetch-templates.ts
new file mode 100644
index 00000000000..37bd70479f5
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/fetch-templates.ts
@@ -0,0 +1,230 @@
+/**
+ * Fetch n8n.io public template catalog for criteria-driven curation.
+ *
+ * Two passes:
+ *   Pass 1 (list)   – paginate the templates list endpoint, persist each page,
+ *                     concat into examples/_raw/_catalog.json. Cheap metadata only.
+ *   Pass 2 (detail) – per-id fetch of the full workflow JSON. Called by
+ *                     regenerate-examples.ts only for candidates the rubric picks.
+ *
+ * Usage:
+ *   pnpm fetch-templates              # full catalog walk (pass 1)
+ *   pnpm fetch-templates --rebuild    # ignore cached pages, re-walk
+ *
+ * Both passes are resumable: existing files are skipped on rerun.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+const RAW_DIR = path.resolve(__dirname, '../examples/_raw');
+const LIST_DIR = path.join(RAW_DIR, '_list');
+const CATALOG_FILE = path.join(RAW_DIR, '_catalog.json');
+const DETAIL_DIR = RAW_DIR;
+
+// Search endpoint paginates correctly (api.n8n.io/api/templates/workflows ignores ?page=).
+// Mirrors the working pattern in scripts/fetch-test-workflows.ts.
+const LIST_URL = 'https://n8n.io/api/product-api/workflows/search';
+const DETAIL_URL = 'https://api.n8n.io/api/workflows';
+
+const ROWS_PER_PAGE = 200;
+const RATE_LIMIT_MS = 200; // ~5 req/s
+const MAX_RETRIES = 3;
+const FETCH_TIMEOUT_MS = 30_000;
+
+export interface CatalogEntry {
+	id: number;
+	name: string;
+	description?: string;
+	totalViews: number;
+	createdAt: string;
+	user: { username: string; verified: boolean };
+	price?: number | null;
+	purchaseUrl: string | null;
+	nodes: Array<{ name: string; group?: string; displayName?: string }>;
+}
+
+interface ListResponse {
+	totalWorkflows: number;
+	workflows: CatalogEntry[];
+}
+
+export interface DetailResponse {
+	data: {
+		id: number;
+		attributes: {
+			name: string;
+			description: string;
+			workflow: {
+				nodes: Array<Record<string, unknown>>;
+				connections: Record<string, unknown>;
+				meta?: Record<string, unknown>;
+				pinData?: Record<string, unknown>;
+				settings?: Record<string, unknown>;
+			};
+			workflowInfo?: {
+				nodeCount: number;
+				nodeTypes: Record<string, { count: number }>;
+			};
+			createdAt: string;
+			updatedAt: string;
+			views: number;
+			recentViews: number;
+			hidden: boolean;
+			username: string;
+			status: string;
+			price: number | null;
+			difficulty: string | null;
+			readyToDemo: boolean | null;
+		};
+	};
+	meta: Record<string, unknown>;
+}
+
+const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+async function politeFetch<T>(url: string, attempt = 1): Promise<T | null> {
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+		if (response.status === 429 || response.status >= 500) {
+			if (attempt > MAX_RETRIES) {
+				console.error(`  Giving up on ${url} after ${MAX_RETRIES} retries (${response.status})`);
+				return null;
+			}
+			const backoff = 2 ** attempt * 1000;
+			console.log(
+				`  ${response.status} from ${url}, backing off ${backoff}ms (attempt ${attempt})`,
+			);
+			await sleep(backoff);
+			return politeFetch<T>(url, attempt + 1);
+		}
+		if (!response.ok) {
+			console.error(`  ${response.status} ${response.statusText}: ${url}`);
+			return null;
+		}
+		return (await response.json()) as T;
+	} catch (error) {
+		if (attempt > MAX_RETRIES) {
+			console.error(`  Network error on ${url} after ${MAX_RETRIES} retries:`, error);
+			return null;
+		}
+		const backoff = 2 ** attempt * 1000;
+		console.log(`  Network error on ${url}, backing off ${backoff}ms (attempt ${attempt})`);
+		await sleep(backoff);
+		return politeFetch<T>(url, attempt + 1);
+	}
+}
+
+function ensureDirs() {
+	for (const dir of [RAW_DIR, LIST_DIR]) {
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	}
+}
+
+function pagePath(page: number) {
+	return path.join(LIST_DIR, `page-${String(page).padStart(4, '0')}.json`);
+}
+
+export async function fetchCatalog(opts: { rebuild?: boolean } = {}): Promise<CatalogEntry[]> {
+	ensureDirs();
+
+	console.log('Pass 1: walking template catalog...\n');
+	const allEntries: CatalogEntry[] = [];
+	let page = 1;
+	let totalExpected: number | undefined;
+
+	while (true) {
+		const cachePath = pagePath(page);
+		let response: ListResponse | null;
+
+		if (!opts.rebuild && fs.existsSync(cachePath)) {
+			response = JSON.parse(fs.readFileSync(cachePath, 'utf-8')) as ListResponse;
+			console.log(`  Page ${page}: ${response.workflows.length} workflows (cached)`);
+		} else {
+			const url = `${LIST_URL}?page=${page}&rows=${ROWS_PER_PAGE}`;
+			response = await politeFetch<ListResponse>(url);
+			if (response === null) {
+				// Fail fast: writing a partial catalog would look valid on disk
+				// but silently drop later pages, masking the failure.
+				throw new Error(`Catalog walk failed at page ${page}; refusing to write partial catalog`);
+			}
+			fs.writeFileSync(cachePath, JSON.stringify(response, null, 2));
+			console.log(
+				`  Page ${page}: ${response.workflows.length} workflows (fetched, total=${response.totalWorkflows})`,
+			);
+			await sleep(RATE_LIMIT_MS);
+		}
+
+		if (totalExpected === undefined) totalExpected = response.totalWorkflows;
+		if (response.workflows.length === 0) break;
+		allEntries.push(...response.workflows);
+		if (allEntries.length >= response.totalWorkflows) break;
+		page++;
+	}
+
+	const dedupedById = new Map<number, CatalogEntry>();
+	for (const entry of allEntries) dedupedById.set(entry.id, entry);
+	const catalog = Array.from(dedupedById.values());
+
+	fs.writeFileSync(CATALOG_FILE, JSON.stringify(catalog, null, 2));
+	console.log(
+		`\nWrote ${catalog.length} unique entries to ${path.relative(process.cwd(), CATALOG_FILE)} (server total=${totalExpected})\n`,
+	);
+
+	return catalog;
+}
+
+function detailPath(id: number) {
+	return path.join(DETAIL_DIR, `${id}.json`);
+}
+
+export async function fetchDetail(
+	id: number,
+	opts: { force?: boolean } = {},
+): Promise<DetailResponse | null> {
+	ensureDirs();
+	const cachePath = detailPath(id);
+
+	if (!opts.force && fs.existsSync(cachePath)) {
+		try {
+			return JSON.parse(fs.readFileSync(cachePath, 'utf-8')) as DetailResponse;
+		} catch {
+			// fall through to refetch
+		}
+	}
+
+	const response = await politeFetch<DetailResponse>(`${DETAIL_URL}/${id}`);
+	if (response === null) return null;
+	fs.writeFileSync(cachePath, JSON.stringify(response, null, 2));
+	await sleep(RATE_LIMIT_MS);
+	return response;
+}
+
+export function loadCachedCatalog(): CatalogEntry[] {
+	if (!fs.existsSync(CATALOG_FILE)) {
+		throw new Error(`Catalog not found at ${CATALOG_FILE}. Run \`pnpm fetch-templates\` first.`);
+	}
+	return JSON.parse(fs.readFileSync(CATALOG_FILE, 'utf-8')) as CatalogEntry[];
+}
+
+export function loadCachedDetail(id: number): DetailResponse | null {
+	const p = detailPath(id);
+	if (!fs.existsSync(p)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(p, 'utf-8')) as DetailResponse;
+	} catch {
+		return null;
+	}
+}
+
+async function main() {
+	const rebuild = process.argv.includes('--rebuild');
+	const catalog = await fetchCatalog({ rebuild });
+	console.log(`Done. Catalog has ${catalog.length} entries.`);
+}
+
+if (require.main === module) {
+	main().catch((error) => {
+		console.error(error);
+		process.exit(1);
+	});
+}
diff --git a/packages/@n8n/workflow-sdk/scripts/jest-global-setup.ts b/packages/@n8n/workflow-sdk/scripts/jest-global-setup.ts
new file mode 100644
index 00000000000..a5f1e841ca6
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/jest-global-setup.ts
@@ -0,0 +1,10 @@
+/**
+ * Jest globalSetup hook: extract committed zips into the expected on-disk
+ * layout before any test runs. We can't rely on npm/pnpm's pretest hook here
+ * because CI invokes `test:unit` (turbo task), not `test`.
+ */
+import { extractAllWorkflows } from './extract-workflows';
+
+module.exports = () => {
+	extractAllWorkflows();
+};
diff --git a/packages/@n8n/workflow-sdk/scripts/regenerate-examples.ts b/packages/@n8n/workflow-sdk/scripts/regenerate-examples.ts
new file mode 100644
index 00000000000..fa508aa3050
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/scripts/regenerate-examples.ts
@@ -0,0 +1,551 @@
+/**
+ * Regenerate `examples/manifest.json`, `examples/workflows/*.json`, and
+ * `examples/templates.zip` from the cached public-template catalog.
+ *
+ * The goal is a small, diverse set of high-quality real workflows the builder
+ * agent can grep when constructing new ones. Diversity beats raw popularity:
+ * we'd rather have one good `webhook + Slack + AI + branching` example than
+ * ten of them.
+ *
+ * Stage 1 — Catalog gate + cheap score (`scoreCatalogEntry`)
+ *   For every entry in the cached catalog, drop paid templates, unverified
+ *   authors, and oversized workflows. Score survivors on `traction` (log-scaled
+ *   views) and `recency` (linear decay from 90→730 days). By default the full
+ *   survivor set is used; pass `--candidates=N` to cap the detail-fetch budget
+ *   on a cold cache.
+ *
+ * Stage 2 — Detail fetch + full-rubric score (`scoreDetailedTemplate`)
+ *   For each candidate, fetch its detail JSON (cached), re-gate on real node
+ *   count + trigger presence, compute its bucket key
+ *   `(triggerType, primaryIntegration, hasAI, controlFlowKind)`, and score on
+ *   the full 6-dimension rubric (traction, recency, coverage, aiAgent, clarity,
+ *   density). Weights live in `criteria.ts` — `coverage` is the dominant
+ *   weight (35) because it drives bucket diversity.
+ *
+ * Stage 3 — Greedy round-robin pick
+ *   Loop until `--target` (default 50) accepted: re-score every remaining
+ *   candidate against the *current* `acceptedBuckets` (coverage decays once a
+ *   bucket fills), pick the highest scorer, validate it round-trips through
+ *   `generateWorkflowCode` + `emitInstanceAi`, accept on success. Validation
+ *   failures are logged to `_failures.log` and the candidate is dropped.
+ *
+ * Stage 3b — Coverage patch for must-cover node types
+ *   `MUST_COVER_NODE_TYPES` (Postgres + all langchain vector stores) must each
+ *   appear somewhere in the manifest. For any missing type, first scan the
+ *   1000-candidate pool; if none has it, fall back to scanning the full
+ *   catalog and fetching detail on demand for up to 25 ranked candidates.
+ *   This is why the final count usually exceeds `--target`.
+ *
+ * Stage 4 — Write outputs
+ *   Clear `examples/workflows/`, write one JSON per accepted candidate, write
+ *   `manifest.json` sorted by score (with the per-dimension breakdown so picks
+ *   are reviewable), write `_catalog-snapshot.json`, then pack the workflow
+ *   JSONs into `examples/templates.zip`. Only the manifest and the zip are
+ *   committed; the unpacked JSONs are gitignored and recreated on demand by
+ *   `examples-loader`.
+ *
+ * Usage:
+ *   pnpm regenerate-examples                  # default target 50
+ *   pnpm regenerate-examples --target=100     # explicit target
+ *   pnpm regenerate-examples --candidates=2000 # cap detail-fetch budget
+ */
+import AdmZip from 'adm-zip';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { generateWorkflowCode, emitInstanceAi } from '../src/codegen';
+import {
+	bucketKey,
+	bucketKeyToString,
+	mechanicalGateCatalog,
+	mechanicalGateDetail,
+	scoreCatalogEntry,
+	scoreDetailedTemplate,
+	type BucketKey,
+	type ScoreResult,
+} from './criteria';
+import {
+	fetchDetail,
+	loadCachedCatalog,
+	type CatalogEntry,
+	type DetailResponse,
+} from './fetch-templates';
+
+const EXAMPLES_DIR = path.resolve(__dirname, '../examples');
+const WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+const MANIFEST_PATH = path.join(EXAMPLES_DIR, 'manifest.json');
+const ZIP_PATH = path.join(EXAMPLES_DIR, 'templates.zip');
+const SNAPSHOT_PATH = path.join(EXAMPLES_DIR, '_catalog-snapshot.json');
+const FAILURES_LOG = path.join(EXAMPLES_DIR, '_failures.log');
+
+const DEFAULT_TARGET = 50;
+// No cap by default — process the full catalog. Detail JSONs are cached on
+// disk in `examples/_raw/`, so warm runs are cheap. Pass `--candidates=N` to
+// bound the detail-fetch budget on a cold cache.
+const DEFAULT_CANDIDATES = Infinity;
+
+/**
+ * Popular catalog node types that must be represented in the manifest. After
+ * the main bucket-pick loop, any of these missing from the manifest gets a
+ * coverage patch: we force-include the highest-scoring eligible candidate
+ * containing that type. Extends the manifest beyond `target`.
+ *
+ * If a must-cover type's candidates didn't make the top-K catalog cohort, the
+ * patch step falls back to fetching detail for the type's highest-scoring
+ * catalog entries on demand.
+ */
+const MUST_COVER_NODE_TYPES = [
+	'n8n-nodes-base.postgres',
+	'@n8n/n8n-nodes-langchain.vectorStorePinecone',
+	'@n8n/n8n-nodes-langchain.vectorStoreSupabase',
+	'@n8n/n8n-nodes-langchain.vectorStoreQdrant',
+	'@n8n/n8n-nodes-langchain.vectorStoreInMemory',
+	'@n8n/n8n-nodes-langchain.vectorStorePGVector',
+	'@n8n/n8n-nodes-langchain.vectorStoreMongoDBAtlas',
+	'@n8n/n8n-nodes-langchain.vectorStoreWeaviate',
+	'@n8n/n8n-nodes-langchain.vectorStoreMilvus',
+	'@n8n/n8n-nodes-langchain.vectorStoreRedis',
+] as const;
+
+interface CliArgs {
+	target: number;
+	candidates: number;
+}
+
+interface ManifestEntry {
+	id: number;
+	slug: string;
+	name: string;
+	description: string;
+	nodes: string[];
+	tags: string[];
+	triggerType: string;
+	hasAI: boolean;
+	score: number;
+	scoreBreakdown: ScoreResult['breakdown'];
+	source: string;
+	author: string;
+	success: true;
+}
+
+interface SnapshotEntry {
+	id: number;
+	name: string;
+	score: number;
+	createdAt: string;
+	totalViews: number;
+	picked: boolean;
+	dropReason?: string;
+}
+
+function parseArgs(): CliArgs {
+	const args = { target: DEFAULT_TARGET, candidates: DEFAULT_CANDIDATES };
+	for (const a of process.argv.slice(2)) {
+		const [k, v] = a.split('=');
+		if (k === '--target') args.target = Number(v);
+		else if (k === '--candidates') args.candidates = Number(v);
+	}
+	return args;
+}
+
+function ensureDirs() {
+	for (const dir of [EXAMPLES_DIR, WORKFLOWS_DIR]) {
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	}
+}
+
+function clearFailuresLog() {
+	if (fs.existsSync(FAILURES_LOG)) fs.unlinkSync(FAILURES_LOG);
+}
+
+function logFailure(id: number, name: string, reason: string) {
+	fs.appendFileSync(FAILURES_LOG, `${id} | ${name} | ${reason}\n`);
+}
+
+function makeSlug(id: number, name: string): string {
+	const base = name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-|-$/g, '')
+		.slice(0, 60);
+	return `${base || 'workflow'}-${id}`;
+}
+
+function detailToWorkflowJson(detail: DetailResponse) {
+	const attrs = detail.data.attributes;
+	return {
+		id: `wf-${detail.data.id}`,
+		name: attrs.name,
+		nodes: attrs.workflow.nodes,
+		connections: attrs.workflow.connections,
+		settings: attrs.workflow.settings ?? {},
+		pinData: attrs.workflow.pinData ?? {},
+	};
+}
+
+function buildTags(detail: DetailResponse, key: BucketKey): string[] {
+	const tags: string[] = [`trigger:${key.triggerType}`];
+	if (key.hasAI) tags.push('ai');
+	if (key.primaryIntegration && key.primaryIntegration !== 'none') {
+		tags.push(`integration:${key.primaryIntegration}`);
+	}
+	return tags;
+}
+
+function uniqueNodeTypes(detail: DetailResponse): string[] {
+	const seen = new Set<string>();
+	for (const node of detail.data.attributes.workflow.nodes ?? []) {
+		const type = String(node.type ?? '');
+		if (type) seen.add(type);
+	}
+	return Array.from(seen);
+}
+
+function validateRoundtrip(detail: DetailResponse): { ok: true } | { ok: false; reason: string } {
+	const json = detailToWorkflowJson(detail);
+	let firstPass: string;
+	try {
+		firstPass = generateWorkflowCode(json);
+	} catch (error) {
+		return { ok: false, reason: `codegen threw: ${(error as Error).message}` };
+	}
+	if (!firstPass || firstPass.length === 0) {
+		return { ok: false, reason: 'codegen produced empty output' };
+	}
+	try {
+		const wrapped = emitInstanceAi(json);
+		if (!wrapped.includes("from '@n8n/workflow-sdk'")) {
+			return { ok: false, reason: 'emitInstanceAi produced output without SDK import' };
+		}
+	} catch (error) {
+		return { ok: false, reason: `emitInstanceAi threw: ${(error as Error).message}` };
+	}
+	return { ok: true };
+}
+
+interface ScoredCandidate {
+	entry: CatalogEntry;
+	detail: DetailResponse;
+	bucket: BucketKey;
+	bucketStr: string;
+	scoreAtPick: ScoreResult;
+}
+
+async function main() {
+	const args = parseArgs();
+	ensureDirs();
+	clearFailuresLog();
+
+	const candidatesLabel = Number.isFinite(args.candidates) ? args.candidates : 'all';
+	console.log(`Regenerating examples (target=${args.target}, candidates=${candidatesLabel})\n`);
+
+	// Stage 1: catalog-stage filter and score
+	const catalog = loadCachedCatalog();
+	console.log(`Loaded ${catalog.length} catalog entries`);
+
+	const snapshot: SnapshotEntry[] = [];
+	const survivors: Array<{ entry: CatalogEntry; score: number }> = [];
+
+	for (const entry of catalog) {
+		const gate = mechanicalGateCatalog(entry);
+		if (!gate.ok) {
+			snapshot.push({
+				id: entry.id,
+				name: entry.name,
+				score: 0,
+				createdAt: entry.createdAt,
+				totalViews: entry.totalViews,
+				picked: false,
+				dropReason: gate.reason,
+			});
+			continue;
+		}
+		const s = scoreCatalogEntry(entry);
+		survivors.push({ entry, score: s.total });
+		snapshot.push({
+			id: entry.id,
+			name: entry.name,
+			score: s.total,
+			createdAt: entry.createdAt,
+			totalViews: entry.totalViews,
+			picked: false,
+		});
+	}
+
+	survivors.sort((a, b) => b.score - a.score);
+	const topCandidates = survivors.slice(0, args.candidates);
+	console.log(
+		`Stage 1: ${survivors.length} catalog survivors → top ${topCandidates.length} for detail fetch`,
+	);
+
+	// Stage 2: fetch detail and full-rubric score
+	const scored: ScoredCandidate[] = [];
+	let detailFetched = 0;
+	let detailDropped = 0;
+	let detailFailed = 0;
+
+	for (let i = 0; i < topCandidates.length; i++) {
+		const { entry } = topCandidates[i];
+		if (i % 50 === 0) {
+			console.log(`  detail fetch ${i}/${topCandidates.length}...`);
+		}
+		const detail = await fetchDetail(entry.id);
+		if (!detail) {
+			detailFailed++;
+			logFailure(entry.id, entry.name, 'detail fetch failed');
+			continue;
+		}
+		detailFetched++;
+		const gate = mechanicalGateDetail(detail);
+		if (!gate.ok) {
+			detailDropped++;
+			logFailure(entry.id, entry.name, `detail gate: ${gate.reason}`);
+			continue;
+		}
+		const bucket = bucketKey(detail);
+		// score with empty running set; we'll re-score during bucket pick
+		const s = scoreDetailedTemplate(entry, detail, []);
+		scored.push({
+			entry,
+			detail,
+			bucket,
+			bucketStr: bucketKeyToString(bucket),
+			scoreAtPick: s,
+		});
+	}
+
+	console.log(
+		`Stage 2: detail fetched=${detailFetched}, dropped=${detailDropped}, failed=${detailFailed}, scored=${scored.length}`,
+	);
+
+	// Stage 3: greedy round-robin pick by bucket count, recomputing coverage
+	const accepted: ScoredCandidate[] = [];
+	const acceptedBuckets: BucketKey[] = [];
+
+	while (accepted.length < args.target) {
+		let best: { idx: number; score: number; cand: ScoredCandidate } | null = null;
+		for (let i = 0; i < scored.length; i++) {
+			const cand = scored[i];
+			if (accepted.includes(cand)) continue;
+			const fresh = scoreDetailedTemplate(cand.entry, cand.detail, acceptedBuckets);
+			if (best === null || fresh.total > best.score) {
+				best = { idx: i, score: fresh.total, cand };
+			}
+		}
+		if (best === null) break;
+
+		// Validate before accepting
+		const valid = validateRoundtrip(best.cand.detail);
+		if (!valid.ok) {
+			scored.splice(best.idx, 1);
+			logFailure(best.cand.entry.id, best.cand.entry.name, `validation: ${valid.reason}`);
+			continue;
+		}
+
+		const fresh = scoreDetailedTemplate(best.cand.entry, best.cand.detail, acceptedBuckets);
+		best.cand.scoreAtPick = fresh;
+		accepted.push(best.cand);
+		acceptedBuckets.push(best.cand.bucket);
+		scored.splice(best.idx, 1);
+	}
+
+	console.log(`Stage 3: accepted ${accepted.length} workflows after validation`);
+
+	// Stage 3b: coverage patch — force-include must-cover node types missing from accepted
+	const acceptedTypes = new Set<string>();
+	for (const cand of accepted) {
+		for (const node of cand.detail.data.attributes.workflow.nodes ?? []) {
+			acceptedTypes.add(String(node.type ?? ''));
+		}
+	}
+	let patchedCount = 0;
+	for (const mustType of MUST_COVER_NODE_TYPES) {
+		if (acceptedTypes.has(mustType)) continue;
+
+		// First-tier: try scored candidates already in our pool.
+		const fromScored = scored
+			.map((cand) => {
+				const types = (cand.detail.data.attributes.workflow.nodes ?? []).map((n) =>
+					String(n.type ?? ''),
+				);
+				if (!types.includes(mustType)) return null;
+				const fresh = scoreDetailedTemplate(cand.entry, cand.detail, acceptedBuckets);
+				return { cand, score: fresh.total };
+			})
+			.filter((x): x is { cand: ScoredCandidate; score: number } => x !== null)
+			.sort((a, b) => b.score - a.score);
+
+		let added = false;
+		for (const { cand, score } of fromScored) {
+			const valid = validateRoundtrip(cand.detail);
+			if (!valid.ok) {
+				logFailure(cand.entry.id, cand.entry.name, `coverage-patch validation: ${valid.reason}`);
+				continue;
+			}
+			const fresh = scoreDetailedTemplate(cand.entry, cand.detail, acceptedBuckets);
+			cand.scoreAtPick = fresh;
+			accepted.push(cand);
+			acceptedBuckets.push(cand.bucket);
+			scored.splice(scored.indexOf(cand), 1);
+			for (const node of cand.detail.data.attributes.workflow.nodes ?? []) {
+				acceptedTypes.add(String(node.type ?? ''));
+			}
+			console.log(
+				`  coverage patch (+1 for ${mustType}): id=${cand.entry.id} score=${score.toFixed(2)} ${cand.entry.name.slice(0, 60)}`,
+			);
+			patchedCount++;
+			added = true;
+			break;
+		}
+		if (added) continue;
+
+		// Second-tier: type wasn't in the top-K candidate pool. Scan the full
+		// catalog for entries whose sparse list contains the type, fetch detail
+		// on demand (cached after first hit), and accept the first that passes
+		// gate + roundtrip. Ranked by catalog-stage score so we try the
+		// strongest candidate first.
+		const catalogCandidates = catalog
+			.filter((entry) => (entry.nodes ?? []).some((n) => n.name === mustType))
+			.filter((entry) => mechanicalGateCatalog(entry).ok)
+			.map((entry) => ({ entry, score: scoreCatalogEntry(entry).total }))
+			.sort((a, b) => b.score - a.score)
+			.slice(0, 25); // bounded — don't go fetching the whole tail
+
+		for (const { entry } of catalogCandidates) {
+			const detail = await fetchDetail(entry.id);
+			if (!detail) continue;
+			if (!mechanicalGateDetail(detail).ok) continue;
+			// Catalog `entry.nodes` is a sparse list that can drift from the
+			// real workflow JSON; re-verify against the detail before accepting.
+			const detailHasType = (detail.data.attributes.workflow.nodes ?? []).some(
+				(n) => String(n.type ?? '') === mustType,
+			);
+			if (!detailHasType) continue;
+			const valid = validateRoundtrip(detail);
+			if (!valid.ok) {
+				logFailure(entry.id, entry.name, `coverage-patch fallback validation: ${valid.reason}`);
+				continue;
+			}
+			const bucket = bucketKey(detail);
+			const fresh = scoreDetailedTemplate(entry, detail, acceptedBuckets);
+			const cand: ScoredCandidate = {
+				entry,
+				detail,
+				bucket,
+				bucketStr: bucketKeyToString(bucket),
+				scoreAtPick: fresh,
+			};
+			accepted.push(cand);
+			acceptedBuckets.push(bucket);
+			for (const node of detail.data.attributes.workflow.nodes ?? []) {
+				acceptedTypes.add(String(node.type ?? ''));
+			}
+			console.log(
+				`  coverage patch fallback (+1 for ${mustType}): id=${entry.id} score=${fresh.total.toFixed(2)} ${entry.name.slice(0, 60)}`,
+			);
+			patchedCount++;
+			break;
+		}
+	}
+	if (patchedCount > 0) {
+		console.log(`Stage 3b: coverage patch added ${patchedCount} workflows`);
+	}
+	console.log();
+
+	// Stage 4: write workflows + manifest
+	// Clear existing committed workflow files
+	for (const f of fs.readdirSync(WORKFLOWS_DIR)) {
+		if (f.endsWith('.json')) fs.unlinkSync(path.join(WORKFLOWS_DIR, f));
+	}
+
+	const manifestEntries: ManifestEntry[] = [];
+	const slugSet = new Set<string>();
+	for (const cand of accepted) {
+		const baseSlug = makeSlug(cand.entry.id, cand.entry.name);
+		let slug = baseSlug;
+		let suffix = 2;
+		while (slugSet.has(slug)) slug = `${baseSlug}-${suffix++}`;
+		slugSet.add(slug);
+
+		const wfJson = detailToWorkflowJson(cand.detail);
+		fs.writeFileSync(path.join(WORKFLOWS_DIR, `${slug}.json`), JSON.stringify(wfJson, null, 2));
+
+		const tags = buildTags(cand.detail, cand.bucket);
+		manifestEntries.push({
+			id: cand.entry.id,
+			slug,
+			name: cand.entry.name,
+			description: cand.detail.data.attributes.description ?? '',
+			nodes: uniqueNodeTypes(cand.detail),
+			tags,
+			triggerType: cand.bucket.triggerType,
+			hasAI: cand.bucket.hasAI,
+			score: Number(cand.scoreAtPick.total.toFixed(2)),
+			scoreBreakdown: {
+				traction: Number(cand.scoreAtPick.breakdown.traction.toFixed(3)),
+				recency: Number(cand.scoreAtPick.breakdown.recency.toFixed(3)),
+				coverage: Number(cand.scoreAtPick.breakdown.coverage.toFixed(3)),
+				aiAgent: Number(cand.scoreAtPick.breakdown.aiAgent.toFixed(3)),
+				clarity: Number(cand.scoreAtPick.breakdown.clarity.toFixed(3)),
+				density: Number(cand.scoreAtPick.breakdown.density.toFixed(3)),
+			},
+			source: `https://n8n.io/workflows/${cand.entry.id}`,
+			author: cand.detail.data.attributes.username || cand.entry.user.username || 'unknown',
+			success: true,
+		});
+
+		// Mark in snapshot
+		const snap = snapshot.find((s) => s.id === cand.entry.id);
+		if (snap) snap.picked = true;
+	}
+
+	manifestEntries.sort((a, b) => b.score - a.score);
+	fs.writeFileSync(
+		MANIFEST_PATH,
+		JSON.stringify(
+			{
+				generatedAt: new Date().toISOString(),
+				workflows: manifestEntries,
+			},
+			null,
+			2,
+		),
+	);
+
+	fs.writeFileSync(SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2));
+
+	// Pack workflow JSONs into the committed zip so the unpacked dir can be gitignored.
+	const zip = new AdmZip();
+	for (const entry of manifestEntries) {
+		zip.addLocalFile(path.join(WORKFLOWS_DIR, `${entry.slug}.json`));
+	}
+	zip.writeZip(ZIP_PATH);
+
+	// Bucket distribution report
+	const bucketDistribution = new Map<string, number>();
+	for (const e of manifestEntries) {
+		const k = `${e.triggerType}|${e.hasAI ? 'ai' : 'noai'}`;
+		bucketDistribution.set(k, (bucketDistribution.get(k) ?? 0) + 1);
+	}
+	console.log('Bucket distribution (triggerType × hasAI):');
+	for (const [k, v] of Array.from(bucketDistribution.entries()).sort((a, b) => b[1] - a[1])) {
+		console.log(`  ${v.toString().padStart(3)} | ${k}`);
+	}
+	console.log();
+
+	console.log(
+		`Wrote ${manifestEntries.length} entries to ${path.relative(process.cwd(), MANIFEST_PATH)}`,
+	);
+	console.log(`Wrote workflow JSONs to ${path.relative(process.cwd(), WORKFLOWS_DIR)}/`);
+	console.log(`Wrote zip to ${path.relative(process.cwd(), ZIP_PATH)}`);
+	console.log(`Catalog snapshot: ${path.relative(process.cwd(), SNAPSHOT_PATH)}`);
+	if (fs.existsSync(FAILURES_LOG)) {
+		const failuresCount = fs.readFileSync(FAILURES_LOG, 'utf-8').split('\n').filter(Boolean).length;
+		console.log(`Failures (${failuresCount}): ${path.relative(process.cwd(), FAILURES_LOG)}`);
+	}
+}
+
+main().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
diff --git a/packages/@n8n/workflow-sdk/src/__tests__/examples-roundtrip.test.ts b/packages/@n8n/workflow-sdk/src/__tests__/examples-roundtrip.test.ts
new file mode 100644
index 00000000000..75a595c5b94
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/__tests__/examples-roundtrip.test.ts
@@ -0,0 +1,81 @@
+/**
+ * Roundtrip test for the curated examples set.
+ *
+ * For every entry in `examples/manifest.json` (where success !== false), assert:
+ *   - The source JSON loads
+ *   - `emitInstanceAi()` produces non-empty output with the expected SDK import
+ *   - `parseWorkflowCode()` can parse it back, and the parsed node count matches
+ *
+ * This is the only CI hook for the examples pipeline. It catches both codegen
+ * regressions and SDK drift in a single test, mirroring the pattern in
+ * src/codegen/codegen-roundtrip.test.ts.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { emitInstanceAi } from '../codegen/emit-instance-ai';
+import { parseWorkflowCode } from '../codegen/parse-workflow-code';
+import type { WorkflowJSON } from '../types/base';
+
+const EXAMPLES_DIR = path.resolve(__dirname, '../../examples');
+const MANIFEST_PATH = path.join(EXAMPLES_DIR, 'manifest.json');
+const WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+
+interface ManifestEntry {
+	id: number;
+	slug: string;
+	name: string;
+	success: boolean;
+	skip?: boolean;
+	skipReason?: string;
+}
+
+function loadManifest(): ManifestEntry[] {
+	if (!fs.existsSync(MANIFEST_PATH)) return [];
+	// eslint-disable-next-line n8n-local-rules/no-uncaught-json-parse -- Test fixture file
+	const raw = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf-8')) as { workflows: ManifestEntry[] };
+	return raw.workflows ?? [];
+}
+
+function loadWorkflowJson(slug: string): WorkflowJSON {
+	const filePath = path.join(WORKFLOWS_DIR, `${slug}.json`);
+	// eslint-disable-next-line n8n-local-rules/no-uncaught-json-parse -- Test fixture file
+	return JSON.parse(fs.readFileSync(filePath, 'utf-8')) as WorkflowJSON;
+}
+
+const entries = loadManifest().filter((e) => e.success && !e.skip);
+
+/**
+ * `parseWorkflowCode` does not accept ESM import declarations; emit-instance-ai
+ * adds them. Strip them (and any leading JSDoc header) before parsing.
+ */
+function stripHeader(code: string): string {
+	let body = code;
+	body = body.replace(/^\s*\/\*\*[\s\S]*?\*\/\s*/, '');
+	body = body.replace(/^import\s+\{[^}]*\}\s+from\s+'[^']+'\s*;\s*/m, '');
+	return body.trimStart();
+}
+
+// When the manifest is empty (run `pnpm regenerate-examples` to populate),
+// `it.each([])` registers no tests, which is the desired behaviour.
+describe('examples manifest roundtrip', () => {
+	it.each(entries.map((e) => [e.slug, e]))(
+		'%s: emitInstanceAi → parseWorkflowCode roundtrips',
+		(_slug, entry) => {
+			const json = loadWorkflowJson(entry.slug);
+			const code = emitInstanceAi(json);
+
+			expect(code.length).toBeGreaterThan(0);
+			expect(code).toContain("from '@n8n/workflow-sdk'");
+			expect(code).toContain('workflow(');
+			expect(code).toContain('export default');
+
+			const body = stripHeader(code);
+			const parsed = parseWorkflowCode(body);
+			const sourceNodeCount = json.nodes?.length ?? 0;
+			const parsedNodeCount = parsed.nodes?.length ?? 0;
+			// Some normalisation can shift the count by 1 (e.g. sticky note handling).
+			expect(Math.abs(parsedNodeCount - sourceNodeCount)).toBeLessThanOrEqual(1);
+		},
+	);
+});
diff --git a/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.test.ts b/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.test.ts
new file mode 100644
index 00000000000..6614b5f8a17
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.test.ts
@@ -0,0 +1,363 @@
+import * as sdk from '../index';
+import {
+	emitInstanceAi,
+	buildImports,
+	hoistSharedCredentials,
+	SDK_FUNCTIONS,
+} from './emit-instance-ai';
+import type { WorkflowJSON } from '../types/base';
+
+describe('emit-instance-ai', () => {
+	describe('emitInstanceAi', () => {
+		it('emits a single SDK import line above the workflow body', () => {
+			const wf: WorkflowJSON = {
+				id: 'simple',
+				name: 'Simple',
+				nodes: [
+					{
+						id: '1',
+						name: 'Manual',
+						type: 'n8n-nodes-base.manualTrigger',
+						typeVersion: 1,
+						position: [0, 0],
+						parameters: {},
+					},
+				],
+				connections: {},
+			};
+
+			const out = emitInstanceAi(wf);
+
+			expect(out).toMatch(/^import \{[^}]*\} from '@n8n\/workflow-sdk';/);
+			expect(out).toContain('workflow(');
+			expect(out).toContain('trigger(');
+		});
+
+		it('hoists credentials shared across multiple nodes', () => {
+			const wf: WorkflowJSON = {
+				id: 'shared',
+				name: 'Shared Credentials',
+				nodes: [
+					{
+						id: 't',
+						name: 'Manual',
+						type: 'n8n-nodes-base.manualTrigger',
+						typeVersion: 1,
+						position: [0, 0],
+						parameters: {},
+					},
+					{
+						id: 'a',
+						name: 'Slack A',
+						type: 'n8n-nodes-base.slack',
+						typeVersion: 2.2,
+						position: [100, 0],
+						parameters: { channel: '#a' },
+						credentials: { slackApi: { id: 'cred-1', name: 'Team Slack' } },
+					},
+					{
+						id: 'b',
+						name: 'Slack B',
+						type: 'n8n-nodes-base.slack',
+						typeVersion: 2.2,
+						position: [200, 0],
+						parameters: { channel: '#b' },
+						credentials: { slackApi: { id: 'cred-1', name: 'Team Slack' } },
+					},
+				],
+				connections: {
+					Manual: { main: [[{ node: 'Slack A', type: 'main', index: 0 }]] },
+					'Slack A': { main: [[{ node: 'Slack B', type: 'main', index: 0 }]] },
+				},
+			};
+
+			const out = emitInstanceAi(wf);
+
+			// Top-level const declared once
+			const declMatches = out.match(
+				/const teamSlackCred = newCredential\('Team Slack', 'cred-1'\);/g,
+			);
+			expect(declMatches).not.toBeNull();
+			expect(declMatches!.length).toBe(1);
+
+			// No leftover inline newCredential('Team Slack', 'cred-1') calls in nodes
+			const inlineMatches = out.match(/newCredential\('Team Slack', 'cred-1'\)/g) ?? [];
+			expect(inlineMatches.length).toBe(1); // only the const declaration
+			expect(out).toMatch(/slackApi: teamSlackCred\b/);
+		});
+
+		it('leaves single-use credentials inline', () => {
+			const wf: WorkflowJSON = {
+				id: 'single',
+				name: 'Single Cred',
+				nodes: [
+					{
+						id: 't',
+						name: 'Manual',
+						type: 'n8n-nodes-base.manualTrigger',
+						typeVersion: 1,
+						position: [0, 0],
+						parameters: {},
+					},
+					{
+						id: 's',
+						name: 'Slack',
+						type: 'n8n-nodes-base.slack',
+						typeVersion: 2.2,
+						position: [100, 0],
+						parameters: {},
+						credentials: { slackApi: { id: 'one-only', name: 'Solo' } },
+					},
+				],
+				connections: { Manual: { main: [[{ node: 'Slack', type: 'main', index: 0 }]] } },
+			};
+
+			const out = emitInstanceAi(wf);
+
+			expect(out).not.toMatch(/^const \w+Cred =/m);
+			expect(out).toContain("newCredential('Solo', 'one-only')");
+		});
+
+		it('treats different credential ids of the same name as distinct', () => {
+			const wf: WorkflowJSON = {
+				id: 'distinct',
+				name: 'Distinct',
+				nodes: [
+					{
+						id: 't',
+						name: 'Manual',
+						type: 'n8n-nodes-base.manualTrigger',
+						typeVersion: 1,
+						position: [0, 0],
+						parameters: {},
+					},
+					{
+						id: 'a',
+						name: 'Slack A',
+						type: 'n8n-nodes-base.slack',
+						typeVersion: 2.2,
+						position: [100, 0],
+						parameters: {},
+						credentials: { slackApi: { id: 'one', name: 'Team' } },
+					},
+					{
+						id: 'b',
+						name: 'Slack B',
+						type: 'n8n-nodes-base.slack',
+						typeVersion: 2.2,
+						position: [200, 0],
+						parameters: {},
+						credentials: { slackApi: { id: 'two', name: 'Team' } },
+					},
+				],
+				connections: {
+					Manual: { main: [[{ node: 'Slack A', type: 'main', index: 0 }]] },
+					'Slack A': { main: [[{ node: 'Slack B', type: 'main', index: 0 }]] },
+				},
+			};
+
+			const out = emitInstanceAi(wf);
+
+			// Both occur once → no hoist
+			expect(out).not.toMatch(/^const \w+Cred =/m);
+			expect(out).toContain("newCredential('Team', 'one')");
+			expect(out).toContain("newCredential('Team', 'two')");
+		});
+
+		it('prepends a JSDoc header when supplied', () => {
+			const wf: WorkflowJSON = {
+				id: 'h',
+				name: 'Header',
+				nodes: [
+					{
+						id: 't',
+						name: 'Manual',
+						type: 'n8n-nodes-base.manualTrigger',
+						typeVersion: 1,
+						position: [0, 0],
+						parameters: {},
+					},
+				],
+				connections: {},
+			};
+
+			const header = '/**\n * @template\n * @name Header\n */';
+			const out = emitInstanceAi(wf, { jsdocHeader: header });
+
+			expect(out.startsWith(header)).toBe(true);
+		});
+	});
+
+	describe('buildImports', () => {
+		it('includes only functions actually used in the body', () => {
+			const body = "const t = trigger({ ... }); const c = newCredential('A', '1');";
+			expect(buildImports(body)).toBe(
+				"import { trigger, newCredential } from '@n8n/workflow-sdk';",
+			);
+		});
+
+		it('returns empty string when no SDK functions appear', () => {
+			expect(buildImports('const x = 1;')).toBe('');
+		});
+
+		it('does not match identifier prefixes', () => {
+			// `mynewCredential(` should not include `newCredential` in imports
+			const body = 'const x = mynewCredential(); const y = trigger();';
+			expect(buildImports(body)).toBe("import { trigger } from '@n8n/workflow-sdk';");
+		});
+	});
+
+	describe('SDK_FUNCTIONS drift guard', () => {
+		// Every function exported from `@n8n/workflow-sdk` falls into one of two buckets:
+		//   - SDK_FUNCTIONS  → workflow-callable, must appear in generated import line
+		//   - INTENTIONALLY_EXCLUDED → utility/codegen/validation/type guard, never appears
+		//                              inside an emitted workflow body
+		// When a new export is added, this test fails until it's categorised. That's the
+		// signal to decide whether `emit-instance-ai` should know about it.
+		const INTENTIONALLY_EXCLUDED = new Set<string>([
+			// Classes
+			'PluginRegistry',
+			'ValidationError',
+			'ValidationWarning',
+			// Expression helpers (workflows use `expr()` only; the rest are parser internals)
+			'createFromAIExpression',
+			'isExpression',
+			'nodeJson',
+			'parseExpression',
+			// Type guards (callable but never appear in workflow bodies)
+			'isDataTableType',
+			'isHttpRequestType',
+			'isIfNodeType',
+			'isMergeNodeType',
+			'isNodeChain',
+			'isNodeInstance',
+			'isSplitInBatchesType',
+			'isStickyNoteType',
+			'isSwitchNodeType',
+			'isWebhookType',
+			// Codegen + parse round-trip
+			'emitInstanceAi',
+			'generateWorkflowCode',
+			'parseWorkflowCode',
+			'parseWorkflowCodeToBuilder',
+			// Code-step helpers — appear as arguments to `.code()` callbacks, not as
+			// standalone calls in the emitted body
+			'runOnceForAllItems',
+			'runOnceForEachItem',
+			// Safe-access utilities (used inside .code() callbacks too)
+			'getProperty',
+			'hasProperty',
+			'isPlainObject',
+			// Validation
+			'validateNodeConfig',
+			'validateWorkflow',
+			'setSchemaBaseDirs',
+			// Pin-data + schema discovery
+			'discoverOutputSchemaForNode',
+			'discoverSchemasForNode',
+			'findSchemaForOperation',
+			'inferSchemasFromRunData',
+			'needsPinData',
+			'normalizePinData',
+			// Display-options matching
+			'matchesDisplayOptions',
+			// Plugin registration
+			'registerDefaultPlugins',
+			// Generate-types module (build-time type generation, never appears in workflows)
+			'buildDiscriminatorTree',
+			'extractDiscriminatorCombinations',
+			'extractOutputTypes',
+			'filterPropertiesForVersion',
+			'generateDiscriminatedUnion',
+			'generateDiscriminatorSchemaFile',
+			'generateIndexFile',
+			'generateJsonSchemaFromData',
+			'generateNodeJSDoc',
+			'generateNodeTypeFile',
+			'generatePropertyJSDoc',
+			'generatePropertyLine',
+			'generateResourceIndexSchemaFile',
+			'generateSchemaIndexFile',
+			'generateSchemaPropertyLine',
+			'generateSingleVersionSchemaFile',
+			'generateSingleVersionTypeFile',
+			'generateSplitVersionIndexSchemaFile',
+			'generateSubnodeUnionTypes',
+			'generateSubnodesFile',
+			'generateTypes',
+			'generateVersionIndexFile',
+			'getHighestVersion',
+			'getPackageName',
+			'getPropertiesForCombination',
+			'getSubnodeOutputType',
+			'groupNodesByOutputType',
+			'groupVersionsByProperties',
+			'hasDiscriminatorPattern',
+			'jsonSchemaToTypeScript',
+			'literalUnion',
+			'loadNodeTypes',
+			'mapPropertyToZodSchema',
+			'mapPropertyType',
+			'multiOptionsSchema',
+			'nodeNameToFileName',
+			'optionsWithExpression',
+			'orchestrateGeneration',
+			'planSplitVersionFiles',
+			'planSplitVersionSchemaFiles',
+			'propertyAppliesToVersion',
+			'versionToFileName',
+			'versionToTypeName',
+		]);
+
+		const sdkFunctionExports = new Set(
+			Object.entries(sdk)
+				.filter(([, v]) => typeof v === 'function')
+				.map(([k]) => k),
+		);
+
+		it('categorises every SDK function export', () => {
+			const categorised = new Set([...SDK_FUNCTIONS, ...INTENTIONALLY_EXCLUDED]);
+			const uncategorised = [...sdkFunctionExports].filter((n) => !categorised.has(n)).sort();
+
+			expect(uncategorised).toEqual([]);
+		});
+
+		it('has no stale entries in SDK_FUNCTIONS', () => {
+			const stale = SDK_FUNCTIONS.filter((n) => !sdkFunctionExports.has(n)).sort();
+
+			expect(stale).toEqual([]);
+		});
+
+		it('has no stale entries in INTENTIONALLY_EXCLUDED', () => {
+			const stale = [...INTENTIONALLY_EXCLUDED].filter((n) => !sdkFunctionExports.has(n)).sort();
+
+			expect(stale).toEqual([]);
+		});
+
+		it('does not double-list a function in both sets', () => {
+			const overlap = SDK_FUNCTIONS.filter((n) => INTENTIONALLY_EXCLUDED.has(n)).sort();
+
+			expect(overlap).toEqual([]);
+		});
+	});
+
+	describe('hoistSharedCredentials', () => {
+		it('is a no-op when there are no credentials', () => {
+			const body = 'const x = node({ ... });';
+			expect(hoistSharedCredentials(body)).toBe(body);
+		});
+
+		it('handles three or more shared occurrences', () => {
+			const call = "newCredential('Triple', 't-1')";
+			const body = `const a = node({ c: ${call} });\nconst b = node({ c: ${call} });\nconst c = node({ c: ${call} });`;
+
+			const out = hoistSharedCredentials(body);
+
+			expect(out).toMatch(/const tripleCred = newCredential\('Triple', 't-1'\);/);
+			const callMatches = out.match(/newCredential\('Triple', 't-1'\)/g) ?? [];
+			expect(callMatches.length).toBe(1); // only in const declaration
+			const refMatches = out.match(/c: tripleCred\b/g) ?? [];
+			expect(refMatches.length).toBe(3);
+		});
+	});
+});
diff --git a/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.ts b/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.ts
new file mode 100644
index 00000000000..3e1d7748f8c
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/codegen/emit-instance-ai.ts
@@ -0,0 +1,203 @@
+/**
+ * instance-ai-flavored codegen.
+ *
+ * Wraps `generateWorkflowCode()` to produce TypeScript that matches what the
+ * instance-ai builder agent writes in its sandbox: a top `import` line, shared
+ * credentials hoisted to top-level `const` declarations, and an optional JSDoc
+ * header pulled from manifest metadata.
+ *
+ * Why dedup credentials: real-world workflows often reference the same credential
+ * id from multiple nodes. The default codegen emits the same `newCredential('Name',
+ * 'id')` literal at every callsite, which is structurally correct but obscures the
+ * "these nodes share a credential" pattern. Hoisting makes it explicit.
+ */
+// Import from source module to avoid the codegen/index.ts barrel cycle.
+import { generateCode } from './code-generator';
+import { buildCompositeTree } from './composite-builder';
+import { annotateGraph } from './graph-annotator';
+import { buildSemanticGraph } from './semantic-graph';
+import type { WorkflowJSON } from '../types/base';
+
+function generateWorkflowCode(workflow: WorkflowJSON): string {
+	const graph = buildSemanticGraph(workflow);
+	annotateGraph(graph);
+	const tree = buildCompositeTree(graph);
+	return generateCode(tree, workflow, graph, {});
+}
+
+/**
+ * SDK functions a workflow file may call. Order matters only for tidiness.
+ *
+ * A drift test (`emit-instance-ai.test.ts`) asserts this list stays in sync with the
+ * function exports of `@n8n/workflow-sdk`. When you add or remove a function export,
+ * the test will fail until the new name is placed either here (if a workflow file
+ * may call it) or in the test's intentional-exclusion list (if it's a utility).
+ */
+export const SDK_FUNCTIONS = [
+	'workflow',
+	'trigger',
+	'node',
+	'sticky',
+	'placeholder',
+	'merge',
+	'ifElse',
+	'switchCase',
+	'newCredential',
+	'languageModel',
+	'memory',
+	'tool',
+	'outputParser',
+	'embedding',
+	'embeddings',
+	'vectorStore',
+	'retriever',
+	'documentLoader',
+	'textSplitter',
+	'fromAi',
+	'splitInBatches',
+	'nextBatch',
+	'expr',
+] as const;
+
+export interface EmitInstanceAiOptions {
+	/**
+	 * Optional JSDoc header to prepend (already wrapped in a comment block).
+	 * Typically built from the curation manifest entry.
+	 */
+	jsdocHeader?: string;
+}
+
+/**
+ * Generate a workflow .ts file matching the shape the instance-ai builder agent writes.
+ *
+ * Returns a single string containing: optional JSDoc header, single import line,
+ * hoisted shared credentials, and the workflow body.
+ */
+export function emitInstanceAi(workflow: WorkflowJSON, opts: EmitInstanceAiOptions = {}): string {
+	const body = generateWorkflowCode(workflow);
+	const dedupedBody = hoistSharedCredentials(body);
+	const importLine = buildImports(dedupedBody);
+
+	const sections: string[] = [];
+	if (opts.jsdocHeader) sections.push(opts.jsdocHeader.trim());
+	if (importLine) sections.push(importLine);
+	sections.push(dedupedBody);
+
+	return sections.join('\n\n') + '\n';
+}
+
+/**
+ * Build the single SDK import line by detecting which functions appear in the body.
+ * Looks for `name(` to avoid false positives from substring matches.
+ */
+export function buildImports(body: string): string {
+	const used: string[] = [];
+	for (const fn of SDK_FUNCTIONS) {
+		if (containsCall(body, fn)) used.push(fn);
+	}
+	if (used.length === 0) return '';
+	return `import { ${used.join(', ')} } from '@n8n/workflow-sdk';`;
+}
+
+function containsCall(body: string, fnName: string): boolean {
+	// `\bname\(` — word-boundary anchored to avoid matching `mynewCredential(`
+	const pattern = new RegExp(`\\b${fnName}\\(`);
+	return pattern.test(body);
+}
+
+/**
+ * Find every `newCredential('Name', 'id')` invocation, group by literal args,
+ * and for groups with ≥2 occurrences hoist a `const xCred = newCredential(...)`
+ * declaration above the workflow body and replace each occurrence with the const.
+ *
+ * Single-use credentials are left inline (current codegen behavior) — hoisting them
+ * adds noise without readability gain.
+ */
+export function hoistSharedCredentials(body: string): string {
+	// Two-arg form. Single-arg `newCredential('X')` is rare in real templates and
+	// already concise enough; deduping it provides little benefit.
+	const callPattern = /newCredential\('([^'\\]*)',\s*'([^'\\]*)'\)/g;
+
+	const groups = new Map<string, { match: string; name: string; id: string; count: number }>();
+	let m: RegExpExecArray | null;
+	while ((m = callPattern.exec(body)) !== null) {
+		const [match, name, id] = m;
+		const key = `${name}::${id}`;
+		const existing = groups.get(key);
+		if (existing) {
+			existing.count++;
+		} else {
+			groups.set(key, { match, name, id, count: 1 });
+		}
+	}
+
+	const usedNames = collectExistingIdentifiers(body);
+	const hoists: string[] = [];
+	let result = body;
+
+	// Hoist in stable order: by first-occurrence position in the body
+	const dedupable = Array.from(groups.values())
+		.filter((g) => g.count >= 2)
+		.sort((a, b) => body.indexOf(a.match) - body.indexOf(b.match));
+
+	for (const group of dedupable) {
+		const constName = uniqueConstName(group.name, usedNames);
+		hoists.push(`const ${constName} = ${group.match};`);
+		// Exact-string replace; the match is a literal newCredential(...) call
+		result = splitJoin(result, group.match, constName);
+	}
+
+	if (hoists.length === 0) return body;
+	return `${hoists.join('\n')}\n\n${result}`;
+}
+
+function splitJoin(haystack: string, needle: string, replacement: string): string {
+	return haystack.split(needle).join(replacement);
+}
+
+/**
+ * Build a deterministic, readable `const` name from a credential display name.
+ * `'OpenAI account'` → `openAiAccountCred`. Suffixes a number on collision.
+ */
+export function uniqueConstName(credName: string, used: Set<string>): string {
+	const sanitised = credName
+		.replace(/[^a-zA-Z0-9]+/g, ' ')
+		.trim()
+		.split(/\s+/)
+		.filter(Boolean);
+
+	let camel: string;
+	if (sanitised.length === 0) {
+		camel = 'shared';
+	} else {
+		camel =
+			sanitised[0].charAt(0).toLowerCase() +
+			sanitised[0].slice(1) +
+			sanitised
+				.slice(1)
+				.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+				.join('');
+	}
+
+	const base = `${camel}Cred`;
+	let candidate = base;
+	let i = 1;
+	while (used.has(candidate)) {
+		i++;
+		candidate = `${base}${i}`;
+	}
+	used.add(candidate);
+	return candidate;
+}
+
+/**
+ * Collect identifier-shaped tokens already present in the body so newly hoisted
+ * `const` names don't shadow existing locals.
+ */
+function collectExistingIdentifiers(body: string): Set<string> {
+	const ids = new Set<string>();
+	const pattern = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+	let m: RegExpExecArray | null;
+	while ((m = pattern.exec(body)) !== null) ids.add(m[1]);
+	return ids;
+}
diff --git a/packages/@n8n/workflow-sdk/src/codegen/index.ts b/packages/@n8n/workflow-sdk/src/codegen/index.ts
index 7ddd561f88f..94d361d3e18 100644
--- a/packages/@n8n/workflow-sdk/src/codegen/index.ts
+++ b/packages/@n8n/workflow-sdk/src/codegen/index.ts
@@ -55,6 +55,7 @@ export { buildSemanticGraph } from './semantic-graph';
 export { annotateGraph } from './graph-annotator';
 export { buildCompositeTree } from './composite-builder';
 export { generateCode } from './code-generator';
+export { emitInstanceAi, type EmitInstanceAiOptions } from './emit-instance-ai';
 export {
 	getOutputName,
 	getInputName,
diff --git a/packages/@n8n/workflow-sdk/src/examples-loader.test.ts b/packages/@n8n/workflow-sdk/src/examples-loader.test.ts
new file mode 100644
index 00000000000..c853f8ceb8d
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/examples-loader.test.ts
@@ -0,0 +1,50 @@
+import { getExampleFiles, resetExampleFilesCache } from './examples-loader';
+
+describe('examples-loader', () => {
+	beforeEach(() => resetExampleFilesCache());
+
+	it('loads manifest entries when present', () => {
+		const bundle = getExampleFiles();
+		// In CI without a manifest, both arrays will be empty — that's also valid.
+		// When a manifest exists (post `pnpm regenerate-examples`), assert structure.
+		if (bundle.files.length === 0) {
+			expect(bundle.indexTxt).toBe('');
+			return;
+		}
+
+		// Each generated file has the expected shape
+		for (const file of bundle.files) {
+			expect(file.filename).toMatch(/\.ts$/);
+			expect(file.content).toContain('@template');
+			expect(file.content).toContain("from '@n8n/workflow-sdk'");
+			expect(file.content).toContain('export default');
+			// Untrusted catalog description must not be embedded in JSDoc.
+			expect(file.content).not.toContain('@description');
+		}
+
+		// Index lines match the file count
+		const indexLines = bundle.indexTxt.trim().split('\n');
+		expect(indexLines.length).toBe(bundle.files.length);
+
+		// Each index line has the documented 5-field shape
+		for (const line of indexLines) {
+			const parts = line.split(' | ');
+			expect(parts.length).toBe(5);
+			expect(parts[0]).toMatch(/\.ts$/);
+			expect(parts[4]).toMatch(/^n8n:\d+/);
+		}
+	});
+
+	it('memoises across calls', () => {
+		const a = getExampleFiles();
+		const b = getExampleFiles();
+		expect(a).toBe(b);
+	});
+
+	it('resetExampleFilesCache forces a reload', () => {
+		const a = getExampleFiles();
+		resetExampleFilesCache();
+		const b = getExampleFiles();
+		expect(a).not.toBe(b);
+	});
+});
diff --git a/packages/@n8n/workflow-sdk/src/examples-loader.ts b/packages/@n8n/workflow-sdk/src/examples-loader.ts
new file mode 100644
index 00000000000..1f1e4cad29b
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/examples-loader.ts
@@ -0,0 +1,144 @@
+/**
+ * Runtime loader for the curated workflow examples.
+ *
+ * Reads `examples/manifest.json` + `examples/workflows/*.json`, runs each
+ * through `emitInstanceAi` with a JSDoc header pulled from the manifest entry,
+ * and returns the resulting `.ts` strings plus a flat grep-able `index.txt`.
+ *
+ * Used by the instance-ai sandbox-setup to populate `${workspaceRoot}/examples/`
+ * so the builder agent can grep the index and `cat` matching `.ts` files.
+ *
+ * Results are memoised — the manifest is committed and immutable per package
+ * version, so loading once per process is enough.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { emitInstanceAi } from './codegen/emit-instance-ai';
+import { ensureExtracted } from './examples-zip';
+import type { WorkflowJSON } from './types/base';
+
+// Resolve relative to this file. At runtime this lives at <package>/dist/examples-loader.js,
+// so `../examples` reaches <package>/examples/.
+const EXAMPLES_DIR = path.resolve(__dirname, '..', 'examples');
+const MANIFEST_PATH = path.join(EXAMPLES_DIR, 'manifest.json');
+const WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+
+const NODES_INLINE_LIMIT = 5;
+const INDEX_NODE_SEPARATOR = ',';
+
+export interface ExampleFile {
+	/** Filename relative to `examples/` (e.g. `slack-daily-summary.ts`). */
+	filename: string;
+	/** Full file content: optional JSDoc header, single SDK import, workflow body. */
+	content: string;
+}
+
+export interface ExampleFilesBundle {
+	/** One generated `.ts` string per manifest entry, in score-descending order. */
+	files: ExampleFile[];
+	/** Flat grep-able index, one line per template, sorted by score descending. */
+	indexTxt: string;
+}
+
+interface ManifestEntry {
+	id: number;
+	slug: string;
+	name: string;
+	description: string;
+	nodes: string[];
+	tags: string[];
+	triggerType: string;
+	hasAI: boolean;
+	score: number;
+	source: string;
+	author: string;
+	success: boolean;
+	skip?: boolean;
+}
+
+interface ManifestFile {
+	workflows: ManifestEntry[];
+}
+
+let cached: ExampleFilesBundle | null = null;
+
+/**
+ * Load and prepare the curated examples for sandbox use. Memoised per process.
+ *
+ * Returns an empty bundle if the manifest does not exist (e.g. the consumer is
+ * running against an unfetched workspace). Sandbox-setup checks for an empty
+ * bundle and skips the write.
+ */
+export function getExampleFiles(): ExampleFilesBundle {
+	if (cached !== null) return cached;
+	cached = loadFromDisk();
+	return cached;
+}
+
+/** Reset the memoisation cache. Tests use this; production callers should not. */
+export function resetExampleFilesCache(): void {
+	cached = null;
+}
+
+function loadFromDisk(): ExampleFilesBundle {
+	if (!fs.existsSync(MANIFEST_PATH)) return { files: [], indexTxt: '' };
+	ensureExtracted();
+
+	// eslint-disable-next-line n8n-local-rules/no-uncaught-json-parse -- Internal manifest file
+	const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf-8')) as ManifestFile;
+	const entries = (manifest.workflows ?? [])
+		.filter((e) => e.success && !e.skip)
+		.sort((a, b) => b.score - a.score);
+
+	const files: ExampleFile[] = [];
+	const indexLines: string[] = [];
+
+	for (const entry of entries) {
+		const wfPath = path.join(WORKFLOWS_DIR, `${entry.slug}.json`);
+		if (!fs.existsSync(wfPath)) continue;
+		// eslint-disable-next-line n8n-local-rules/no-uncaught-json-parse -- Internal workflow fixture
+		const wf = JSON.parse(fs.readFileSync(wfPath, 'utf-8')) as WorkflowJSON;
+		const header = buildJsdocHeader(entry);
+		const code = emitInstanceAi(wf, { jsdocHeader: header });
+		files.push({ filename: `${entry.slug}.ts`, content: code });
+		indexLines.push(buildIndexLine(entry));
+	}
+
+	const indexTxt = indexLines.join('\n') + (indexLines.length > 0 ? '\n' : '');
+	return { files, indexTxt };
+}
+
+function buildJsdocHeader(entry: ManifestEntry): string {
+	// Description is intentionally omitted: it's untrusted author-supplied prose
+	// from the public catalog that the builder agent would read verbatim. Name +
+	// nodes + tags + source already disambiguate templates.
+	return [
+		'/**',
+		' * @template',
+		` * @name ${entry.name}`,
+		` * @nodes ${entry.nodes.join(', ')}`,
+		` * @tags ${entry.tags.join(', ')}`,
+		` * @source ${entry.source}`,
+		` * @author ${entry.author}`,
+		' */',
+	].join('\n');
+}
+
+function buildIndexLine(entry: ManifestEntry): string {
+	const truncatedNodes = truncateNodes(entry.nodes);
+	return [
+		`${entry.slug}.ts`,
+		entry.name,
+		truncatedNodes,
+		entry.tags.join(','),
+		`n8n:${entry.id}`,
+	].join(' | ');
+}
+
+function truncateNodes(nodes: string[]): string {
+	if (nodes.length <= NODES_INLINE_LIMIT) return nodes.join(INDEX_NODE_SEPARATOR);
+	const head = nodes.slice(0, NODES_INLINE_LIMIT).join(INDEX_NODE_SEPARATOR);
+	const remaining = nodes.length - NODES_INLINE_LIMIT;
+	return `${head} +${remaining} more`;
+}
diff --git a/packages/@n8n/workflow-sdk/src/examples-zip.ts b/packages/@n8n/workflow-sdk/src/examples-zip.ts
new file mode 100644
index 00000000000..ae633725bf2
--- /dev/null
+++ b/packages/@n8n/workflow-sdk/src/examples-zip.ts
@@ -0,0 +1,73 @@
+/**
+ * Zip extraction utility for the curated workflow examples.
+ *
+ * The 106 workflow JSON files are committed as a single `examples/templates.zip`
+ * to keep the package small. At runtime the loader calls `ensureExtracted()`
+ * which extracts them on first use. The committed `manifest.json` is the
+ * source of truth and is NOT in the zip.
+ */
+import AdmZip from 'adm-zip';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const EXAMPLES_DIR = path.resolve(__dirname, '..', 'examples');
+const ZIP_PATH = path.join(EXAMPLES_DIR, 'templates.zip');
+const MANIFEST_PATH = path.join(EXAMPLES_DIR, 'manifest.json');
+const WORKFLOWS_DIR = path.join(EXAMPLES_DIR, 'workflows');
+
+interface ManifestEntry {
+	slug: string;
+	success: boolean;
+	skip?: boolean;
+}
+
+interface ManifestFile {
+	workflows: ManifestEntry[];
+}
+
+export function zipExists(): boolean {
+	return fs.existsSync(ZIP_PATH);
+}
+
+/**
+ * True if the zip exists and at least one workflow file expected by the
+ * manifest is missing on disk.
+ */
+export function needsExtraction(): boolean {
+	if (!fs.existsSync(ZIP_PATH)) return false;
+	if (!fs.existsSync(MANIFEST_PATH)) return false;
+
+	// eslint-disable-next-line n8n-local-rules/no-uncaught-json-parse -- Internal manifest file
+	const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf-8')) as ManifestFile;
+	for (const entry of manifest.workflows ?? []) {
+		if (!entry.success || entry.skip) continue;
+		const filePath = path.join(WORKFLOWS_DIR, `${entry.slug}.json`);
+		if (!fs.existsSync(filePath)) return true;
+	}
+	return false;
+}
+
+/**
+ * Extract all workflow JSONs from the zip into `examples/workflows/`.
+ * The committed manifest.json is the source of truth and is not in the zip.
+ */
+export function extractFromZip(): void {
+	if (!fs.existsSync(ZIP_PATH)) {
+		throw new Error(`Examples zip not found: ${ZIP_PATH}`);
+	}
+	if (!fs.existsSync(WORKFLOWS_DIR)) {
+		fs.mkdirSync(WORKFLOWS_DIR, { recursive: true });
+	}
+
+	const zip = new AdmZip(ZIP_PATH);
+	for (const entry of zip.getEntries()) {
+		if (entry.isDirectory) continue;
+		zip.extractEntryTo(entry, WORKFLOWS_DIR, false, true);
+	}
+}
+
+export function ensureExtracted(): void {
+	if (needsExtraction()) {
+		extractFromZip();
+	}
+}
diff --git a/packages/@n8n/workflow-sdk/src/index.ts b/packages/@n8n/workflow-sdk/src/index.ts
index 8557b9fb196..fc1ce318866 100644
--- a/packages/@n8n/workflow-sdk/src/index.ts
+++ b/packages/@n8n/workflow-sdk/src/index.ts
@@ -162,6 +162,7 @@ export {
 
 // Code generation
 export { generateWorkflowCode } from './codegen/index';
+export { emitInstanceAi, type EmitInstanceAiOptions } from './codegen/index';
 export { parseWorkflowCode, parseWorkflowCodeToBuilder } from './codegen/parse-workflow-code';
 
 // Type generation utilities (for runtime type generation in CLI)
diff --git a/packages/cli/src/commands/export/__tests__/entities.test.ts b/packages/cli/src/commands/export/__tests__/entities.test.ts
index 3b747d0ed8a..1f731c08663 100644
--- a/packages/cli/src/commands/export/__tests__/entities.test.ts
+++ b/packages/cli/src/commands/export/__tests__/entities.test.ts
@@ -32,6 +32,7 @@ describe('ExportEntitiesCommand', () => {
 					'execution_metadata',
 				]),
 				undefined,
+				{ includeDataTableRows: undefined },
 			);
 		});
 
@@ -53,6 +54,7 @@ describe('ExportEntitiesCommand', () => {
 				'./exports',
 				new Set<string>(),
 				undefined,
+				{ includeDataTableRows: undefined },
 			);
 		});
 
@@ -80,6 +82,29 @@ describe('ExportEntitiesCommand', () => {
 					'execution_metadata',
 				]),
 				'key.txt',
+				{ includeDataTableRows: undefined },
+			);
+		});
+
+		it('should pass includeDataTableRows=false through to the export service', async () => {
+			const command = new ExportEntitiesCommand();
+			// @ts-expect-error Protected property
+			command.flags = {
+				outputDir: './exports',
+				includeDataTableRows: false,
+			};
+			// @ts-expect-error Protected property
+			command.logger = {
+				info: jest.fn(),
+				error: jest.fn(),
+			};
+			await command.run();
+
+			expect(mockExportService.exportEntities).toHaveBeenCalledWith(
+				'./exports',
+				expect.any(Set),
+				undefined,
+				{ includeDataTableRows: false },
 			);
 		});
 	});
diff --git a/packages/cli/src/commands/export/entities.ts b/packages/cli/src/commands/export/entities.ts
index e770ab3595c..4eee58f3e04 100644
--- a/packages/cli/src/commands/export/entities.ts
+++ b/packages/cli/src/commands/export/entities.ts
@@ -17,6 +17,12 @@ const flagsSchema = z.object({
 			'Include execution history data tables, these are excluded by default as they can be very large',
 		)
 		.default(false),
+	includeDataTableRows: z.coerce
+		.boolean()
+		.describe(
+			'Include user-data table row contents. When false, only the data-table schemas (registry rows) are exported.',
+		)
+		.default(true),
 	keyFile: z
 		.string()
 		.describe('Optional path to a file containing a custom encryption key')
@@ -31,6 +37,7 @@ const flagsSchema = z.object({
 		'--outputDir=./exports',
 		'--outputDir=/path/to/backup',
 		'--includeExecutionHistoryDataTables=true',
+		'--includeDataTableRows=false',
 		'--keyFile=/path/to/key.txt',
 		'--outputDir=./exports --keyFile=/path/to/key.txt',
 	],
@@ -50,7 +57,9 @@ export class ExportEntitiesCommand extends BaseCommand<z.infer<typeof flagsSchem
 			excludedDataTables.add('execution_metadata');
 		}
 
-		await Container.get(ExportService).exportEntities(outputDir, excludedDataTables, keyFilePath);
+		await Container.get(ExportService).exportEntities(outputDir, excludedDataTables, keyFilePath, {
+			includeDataTableRows: this.flags.includeDataTableRows,
+		});
 	}
 
 	catch(error: Error) {
diff --git a/packages/cli/src/controllers/oauth/__tests__/oauth1-credential.controller.test.ts b/packages/cli/src/controllers/oauth/__tests__/oauth1-credential.controller.test.ts
index 7c0da5fe770..b3addb5df8e 100644
--- a/packages/cli/src/controllers/oauth/__tests__/oauth1-credential.controller.test.ts
+++ b/packages/cli/src/controllers/oauth/__tests__/oauth1-credential.controller.test.ts
@@ -31,7 +31,7 @@ describe('OAuth1CredentialController', () => {
 	describe('getAuthUri', () => {
 		it('should return a valid auth URI', async () => {
 			const mockResolvedCredential = mock<CredentialsEntity>({ id: '1' });
-			oauthService.getCredential.mockResolvedValueOnce(mockResolvedCredential);
+			oauthService.getCredentialForUpdate.mockResolvedValueOnce(mockResolvedCredential);
 			oauthService.generateAOauth1AuthUri.mockResolvedValueOnce(
 				'https://example.domain/oauth/authorize?oauth_token=random-token',
 			);
@@ -90,7 +90,7 @@ describe('OAuth1CredentialController', () => {
 				createdAt: timestamp,
 				data: 'encrypted-data',
 			};
-			oauthService.getCredential.mockResolvedValueOnce(mockResolvedCredential);
+			oauthService.getCredentialForUpdate.mockResolvedValueOnce(mockResolvedCredential);
 			// @ts-ignore
 			oauthService.getDecryptedData.mockResolvedValue({ csrfSecret: 'invalid' });
 			oauthService.getOAuthCredentials.mockResolvedValueOnce({
diff --git a/packages/cli/src/controllers/oauth/__tests__/oauth2-credential.controller.test.ts b/packages/cli/src/controllers/oauth/__tests__/oauth2-credential.controller.test.ts
index 52ea9ae567b..a35c16424ee 100644
--- a/packages/cli/src/controllers/oauth/__tests__/oauth2-credential.controller.test.ts
+++ b/packages/cli/src/controllers/oauth/__tests__/oauth2-credential.controller.test.ts
@@ -49,7 +49,7 @@ describe('OAuth2CredentialController', () => {
 			);
 
 			const mockResolvedCredential = mock<CredentialsEntity>({ id: '1' });
-			oauthService.getCredential.mockResolvedValueOnce(mockResolvedCredential);
+			oauthService.getCredentialForUpdate.mockResolvedValueOnce(mockResolvedCredential);
 			oauthService.getOAuthCredentials.mockResolvedValueOnce({
 				clientId: 'client_id',
 				clientSecret: 'client_secret',
diff --git a/packages/cli/src/controllers/oauth/oauth1-credential.controller.ts b/packages/cli/src/controllers/oauth/oauth1-credential.controller.ts
index 0ed7c4ee2f5..c7ddab7459e 100644
--- a/packages/cli/src/controllers/oauth/oauth1-credential.controller.ts
+++ b/packages/cli/src/controllers/oauth/oauth1-credential.controller.ts
@@ -22,7 +22,7 @@ export class OAuth1CredentialController {
 	/** Get Authorization url */
 	@Get('/auth')
 	async getAuthUri(req: OAuthRequest.OAuth1Credential.Auth): Promise<string> {
-		const credential = await this.oauthService.getCredential(req);
+		const credential = await this.oauthService.getCredentialForUpdate(req);
 
 		const uri = await this.oauthService.generateAOauth1AuthUri(credential, {
 			cid: credential.id,
diff --git a/packages/cli/src/controllers/oauth/oauth2-credential.controller.ts b/packages/cli/src/controllers/oauth/oauth2-credential.controller.ts
index e82a9f89c55..d4bb34bd4fd 100644
--- a/packages/cli/src/controllers/oauth/oauth2-credential.controller.ts
+++ b/packages/cli/src/controllers/oauth/oauth2-credential.controller.ts
@@ -26,7 +26,7 @@ export class OAuth2CredentialController {
 	/** Get Authorization url */
 	@Get('/auth')
 	async getAuthUri(req: OAuthRequest.OAuth2Credential.Auth): Promise<string> {
-		const credential = await this.oauthService.getCredential(req);
+		const credential = await this.oauthService.getCredentialForUpdate(req);
 
 		const uri = await this.oauthService.generateAOauth2AuthUri(credential, {
 			cid: credential.id,
diff --git a/packages/cli/src/modules/agents/integrations/platforms/__tests__/telegram-integration.test.ts b/packages/cli/src/modules/agents/integrations/platforms/__tests__/telegram-integration.test.ts
index 2ca6fd33a3f..e9e6d635213 100644
--- a/packages/cli/src/modules/agents/integrations/platforms/__tests__/telegram-integration.test.ts
+++ b/packages/cli/src/modules/agents/integrations/platforms/__tests__/telegram-integration.test.ts
@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/unbound-method -- mock-based tests intentionally reference unbound methods */
 import type { Logger } from '@n8n/backend-common';
+import { createHmac } from 'crypto';
 import { mock } from 'jest-mock-extended';
+import type { InstanceSettings } from 'n8n-core';
 
 import { ConflictError } from '@/errors/response-errors/conflict.error';
 import type { UrlService } from '@/services/url.service';
@@ -8,8 +10,20 @@ import type { UrlService } from '@/services/url.service';
 import type { Agent } from '../../../entities/agent.entity';
 import type { AgentRepository } from '../../../repositories/agent.repository';
 import type { AgentChatIntegrationContext } from '../../agent-chat-integration';
+import { loadTelegramAdapter } from '../../esm-loader';
 import { TelegramIntegration } from '../telegram-integration';
 
+jest.mock('../../esm-loader', () => ({
+	loadTelegramAdapter: jest.fn(),
+}));
+
+const mockedLoadTelegramAdapter = loadTelegramAdapter as jest.MockedFunction<
+	typeof loadTelegramAdapter
+>;
+
+const expectedSecret = (encryptionKey: string, agentId: string, credentialId: string) =>
+	createHmac('sha256', encryptionKey).update(`telegram:${agentId}:${credentialId}`).digest('hex');
+
 const makeAgent = (
 	id: string,
 	name: string,
@@ -28,18 +42,42 @@ const makeContext = (
 	...overrides,
 });
 
+const makeIntegration = (
+	opts: {
+		urlService?: jest.Mocked<UrlService>;
+		agentRepository?: jest.Mocked<AgentRepository>;
+		encryptionKey?: string;
+	} = {},
+) => {
+	const urlService =
+		opts.urlService ??
+		(() => {
+			const u = mock<UrlService>();
+			u.getWebhookBaseUrl.mockReturnValue('https://n8n.example.com/');
+			return u;
+		})();
+	const agentRepository = opts.agentRepository ?? mock<AgentRepository>();
+	const instanceSettings = mock<InstanceSettings>({
+		encryptionKey: opts.encryptionKey ?? 'test-encryption-key',
+	});
+	const integration = new TelegramIntegration(
+		mock<Logger>(),
+		urlService,
+		agentRepository,
+		instanceSettings,
+	);
+	return { integration, urlService, agentRepository, instanceSettings };
+};
+
 describe('TelegramIntegration.onBeforeConnect', () => {
-	let integration: TelegramIntegration;
 	let agentRepository: jest.Mocked<AgentRepository>;
-	let urlService: jest.Mocked<UrlService>;
+	let integration: TelegramIntegration;
 	let fetchSpy: jest.SpyInstance;
 
 	beforeEach(() => {
-		agentRepository = mock<AgentRepository>();
-		urlService = mock<UrlService>();
-		urlService.getWebhookBaseUrl.mockReturnValue('https://n8n.example.com/');
-
-		integration = new TelegramIntegration(mock<Logger>(), urlService, agentRepository);
+		const built = makeIntegration();
+		integration = built.integration;
+		agentRepository = built.agentRepository;
 
 		fetchSpy = jest.spyOn(globalThis, 'fetch');
 	});
@@ -97,11 +135,7 @@ describe('TelegramIntegration.requiresLeader', () => {
 		const urlService = mock<UrlService>();
 		urlService.getWebhookBaseUrl.mockReturnValue('http://localhost:5678/');
 
-		const integration = new TelegramIntegration(
-			mock<Logger>(),
-			urlService,
-			mock<AgentRepository>(),
-		);
+		const { integration } = makeIntegration({ urlService });
 
 		expect(integration.requiresLeader()).toBe(true);
 	});
@@ -110,12 +144,80 @@ describe('TelegramIntegration.requiresLeader', () => {
 		const urlService = mock<UrlService>();
 		urlService.getWebhookBaseUrl.mockReturnValue('https://n8n.example.com/');
 
-		const integration = new TelegramIntegration(
-			mock<Logger>(),
-			urlService,
-			mock<AgentRepository>(),
-		);
+		const { integration } = makeIntegration({ urlService });
 
 		expect(integration.requiresLeader()).toBe(false);
 	});
 });
+
+describe('TelegramIntegration secret token', () => {
+	const createTelegramAdapter = jest.fn();
+
+	beforeEach(() => {
+		createTelegramAdapter.mockReset();
+		createTelegramAdapter.mockReturnValue({ marker: 'adapter' });
+		mockedLoadTelegramAdapter.mockReset();
+		mockedLoadTelegramAdapter.mockResolvedValue({
+			createTelegramAdapter,
+		} as unknown as Awaited<ReturnType<typeof loadTelegramAdapter>>);
+	});
+
+	it('createAdapter passes a deterministic secretToken derived from encryptionKey + agentId + credentialId', async () => {
+		const { integration } = makeIntegration({ encryptionKey: 'super-secret-key' });
+
+		await integration.createAdapter(makeContext({ agentId: 'A', credentialId: 'C' }));
+
+		const expected = expectedSecret('super-secret-key', 'A', 'C');
+		expect(createTelegramAdapter).toHaveBeenCalledWith({
+			botToken: 'bot-token',
+			mode: 'webhook',
+			secretToken: expected,
+		});
+	});
+
+	it('two service instances configured with the same encryption key produce identical secrets — the multi-main invariant', async () => {
+		const a = makeIntegration({ encryptionKey: 'shared-cluster-key' });
+		const b = makeIntegration({ encryptionKey: 'shared-cluster-key' });
+
+		await a.integration.createAdapter(makeContext({ agentId: 'agent-X', credentialId: 'cred-Y' }));
+		await b.integration.createAdapter(makeContext({ agentId: 'agent-X', credentialId: 'cred-Y' }));
+
+		const firstSecret = createTelegramAdapter.mock.calls[0][0].secretToken;
+		const secondSecret = createTelegramAdapter.mock.calls[1][0].secretToken;
+		expect(firstSecret).toBe(secondSecret);
+	});
+
+	it('different (agentId, credentialId) pairs produce different secrets', async () => {
+		const { integration } = makeIntegration({ encryptionKey: 'k' });
+
+		await integration.createAdapter(makeContext({ agentId: 'A', credentialId: 'C1' }));
+		await integration.createAdapter(makeContext({ agentId: 'A', credentialId: 'C2' }));
+
+		expect(createTelegramAdapter.mock.calls[0][0].secretToken).not.toBe(
+			createTelegramAdapter.mock.calls[1][0].secretToken,
+		);
+	});
+
+	it('onAfterConnect sends secret_token to Telegram matching the secret used by the adapter', async () => {
+		const fetchSpy = jest
+			.spyOn(globalThis, 'fetch')
+			.mockResolvedValue({ ok: true, text: async () => 'ok' } as Response);
+
+		try {
+			const { integration } = makeIntegration({ encryptionKey: 'cluster-key' });
+
+			await integration.onAfterConnect(makeContext({ agentId: 'agent-Z', credentialId: 'cred-Z' }));
+
+			expect(fetchSpy).toHaveBeenCalledTimes(1);
+			const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit];
+			expect(url).toBe('https://api.telegram.org/botbot-token/setWebhook');
+			const body = JSON.parse(init.body as string) as { url: string; secret_token: string };
+			expect(body.url).toBe(
+				'https://n8n.example.com/rest/projects/proj-1/agents/v2/agent-1/webhooks/telegram',
+			);
+			expect(body.secret_token).toBe(expectedSecret('cluster-key', 'agent-Z', 'cred-Z'));
+		} finally {
+			fetchSpy.mockRestore();
+		}
+	});
+});
diff --git a/packages/cli/src/modules/agents/integrations/platforms/telegram-integration.ts b/packages/cli/src/modules/agents/integrations/platforms/telegram-integration.ts
index b447c0ac11d..8adbe99f8ee 100644
--- a/packages/cli/src/modules/agents/integrations/platforms/telegram-integration.ts
+++ b/packages/cli/src/modules/agents/integrations/platforms/telegram-integration.ts
@@ -1,6 +1,8 @@
 import { Logger } from '@n8n/backend-common';
 import { Service } from '@n8n/di';
 import type { Thread } from 'chat';
+import { createHmac } from 'crypto';
+import { InstanceSettings } from 'n8n-core';
 
 import { ConflictError } from '@/errors/response-errors/conflict.error';
 import { UrlService } from '@/services/url.service';
@@ -63,6 +65,7 @@ export class TelegramIntegration extends AgentChatIntegration {
 		private readonly logger: Logger,
 		private readonly urlService: UrlService,
 		private readonly agentRepository: AgentRepository,
+		private readonly instanceSettings: InstanceSettings,
 	) {
 		super();
 	}
@@ -70,8 +73,9 @@ export class TelegramIntegration extends AgentChatIntegration {
 	async createAdapter(ctx: AgentChatIntegrationContext): Promise<unknown> {
 		const botToken = this.extractBotToken(ctx.credential);
 		const mode = this.getMode();
+		const secretToken = this.deriveSecretToken(ctx.agentId, ctx.credentialId);
 		const { createTelegramAdapter } = await loadTelegramAdapter();
-		return createTelegramAdapter({ botToken, mode });
+		return createTelegramAdapter({ botToken, mode, secretToken });
 	}
 
 	/**
@@ -107,10 +111,11 @@ export class TelegramIntegration extends AgentChatIntegration {
 		if (this.getMode() !== 'webhook') return;
 		const botToken = this.extractBotToken(ctx.credential);
 		const webhookUrl = ctx.webhookUrlFor('telegram');
+		const secretToken = this.deriveSecretToken(ctx.agentId, ctx.credentialId);
 		const resp = await fetch(`https://api.telegram.org/bot${botToken}/setWebhook`, {
 			method: 'POST',
 			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ url: webhookUrl }),
+			body: JSON.stringify({ url: webhookUrl, secret_token: secretToken }),
 		});
 		if (!resp.ok) {
 			throw new Error(`Failed to register Telegram webhook: ${await resp.text()}`);
@@ -149,6 +154,19 @@ export class TelegramIntegration extends AgentChatIntegration {
 		return isPublic ? 'webhook' : 'polling';
 	}
 
+	/**
+	 * Per-integration webhook secret derived deterministically from the cluster
+	 * encryption key. In multi-main mode the webhook is registered exactly once by the
+	 * leader, but every main must verify incoming POSTs. HMAC over an
+	 * `(agentId, credentialId)` lets every main reach the identical secret with
+	 * zero coordination.
+	 */
+	private deriveSecretToken(agentId: string, credentialId: string): string {
+		return createHmac('sha256', this.instanceSettings.encryptionKey)
+			.update(`telegram:${agentId}:${credentialId}`)
+			.digest('hex');
+	}
+
 	private extractBotToken(credential: Record<string, unknown>): string {
 		const token = credential.accessToken;
 		if (typeof token === 'string' && token) {
diff --git a/packages/cli/src/modules/data-table/utils/sql-utils.ts b/packages/cli/src/modules/data-table/utils/sql-utils.ts
index 64f65e1288e..3472216b146 100644
--- a/packages/cli/src/modules/data-table/utils/sql-utils.ts
+++ b/packages/cli/src/modules/data-table/utils/sql-utils.ts
@@ -1,5 +1,6 @@
 import {
 	dataTableColumnNameSchema,
+	dataTableIdSchema,
 	DATA_TABLE_COLUMN_ERROR_MESSAGE,
 	type DataTableCreateColumnSchema,
 } from '@n8n/api-types';
@@ -79,6 +80,10 @@ export function isValidColumnName(name: string) {
 	return dataTableColumnNameSchema.safeParse(name).success;
 }
 
+export function isValidDataTableId(id: string) {
+	return dataTableIdSchema.safeParse(id).success;
+}
+
 export function addColumnQuery(
 	tableName: DataTableUserTableName,
 	column: DataTableCreateColumnSchema,
@@ -187,8 +192,16 @@ export function extractInsertedIds(raw: unknown, dbType: DataSourceOptions['type
 	}
 }
 
+// Convert 0/1 or '0'/'1' to booleans, leaving other values unchanged
+function normalizeBoolean<T>(value: T): T | boolean {
+	if (typeof value === 'boolean') return value;
+	if (value === 1 || value === '1') return true;
+	if (value === 0 || value === '0') return false;
+	return value;
+}
+
 // Convert date objects or strings to dates in UTC
-function normalizeDate(value: DataTableColumnJsType): Date | null {
+export function normalizeDate(value: unknown): Date | null {
 	if (value instanceof Date) return value;
 
 	if (typeof value === 'string') {
@@ -229,14 +242,7 @@ export function normalizeRows(
 			const type = typeMap[key];
 
 			if (type === 'boolean') {
-				// Convert boolean values to true/false
-				if (typeof value === 'boolean') {
-					normalized[key] = value;
-				} else if (value === 1 || value === '1') {
-					normalized[key] = true;
-				} else if (value === 0 || value === '0') {
-					normalized[key] = false;
-				}
+				normalized[key] = normalizeBoolean(value);
 			}
 
 			if (type === 'date' && value !== null && value !== undefined) {
@@ -296,6 +302,32 @@ export function normalizeValueForDatabase(
 	return value;
 }
 
+/**
+ * Normalize a raw value coming from a cross-database data-table export so it can
+ * be inserted into the destination database. Differs from `normalizeValueForDatabase`
+ * by also handling booleans (SQLite stores them as 0/1 INTEGER, Postgres as BOOLEAN)
+ * and SQLite-style date strings without timezone info (treated as UTC).
+ */
+export function normalizeUserRowValueForDatabase(
+	value: unknown,
+	columnType: string | undefined,
+	dbType?: DataSourceOptions['type'],
+): unknown {
+	if (value === null || value === undefined) return null;
+
+	if (columnType === 'boolean') {
+		return normalizeBoolean(value);
+	}
+
+	if (columnType === 'date') {
+		const date = normalizeDate(value);
+		if (date === null) return value;
+		return normalizeValueForDatabase(date, columnType, dbType);
+	}
+
+	return value;
+}
+
 /**
  * Convert a LIKE-style pattern (only % is wildcard) into a SQLite GLOB pattern.
  */
diff --git a/packages/cli/src/modules/instance-ai/__tests__/instance-ai-liveness.service.test.ts b/packages/cli/src/modules/instance-ai/__tests__/instance-ai-liveness.service.test.ts
index 6d20945065f..64ae9173e10 100644
--- a/packages/cli/src/modules/instance-ai/__tests__/instance-ai-liveness.service.test.ts
+++ b/packages/cli/src/modules/instance-ai/__tests__/instance-ai-liveness.service.test.ts
@@ -10,7 +10,12 @@ import {
 	type InstanceAiLivenessTimeoutReason,
 } from '@n8n/instance-ai';
 
-import { INSTANCE_AI_RUN_TIMEOUT_REASON, InstanceAiLivenessService } from '../liveness';
+import {
+	INSTANCE_AI_RUN_TIMEOUT_REASON,
+	InstanceAiLivenessService,
+	type InstanceAiLivenessSweepResult,
+} from '../liveness';
+import type { InstanceAiRunTimeoutDetails } from '../run-timeout-details';
 
 type TestSuspendedRun = {
 	runId: string;
@@ -22,11 +27,13 @@ function createLivenessService() {
 	const policyConfig = createInstanceAiLivenessPolicyConfig();
 	const policy = new InstanceAiLivenessPolicy(policyConfig);
 	const runState = {
-		sweepTimedOut: jest.fn((_policy: InstanceAiLivenessPolicy, _now?: number) => ({
-			activeThreadIds: [] as string[],
-			suspendedThreadIds: [] as string[],
-			confirmationRequestIds: [] as string[],
-		})),
+		sweepTimedOut: jest.fn(
+			(_policy: InstanceAiLivenessPolicy, _now?: number): InstanceAiLivenessSweepResult => ({
+				activeThreadIds: [] as string[],
+				suspendedThreadIds: [] as string[],
+				confirmationRequestIds: [] as string[],
+			}),
+		),
 		cancelActiveRun: jest.fn(
 			(_threadId: string): { runId: string; abortController: AbortController } | undefined =>
 				undefined,
@@ -93,11 +100,27 @@ describe('InstanceAiLivenessService', () => {
 			threadId: 'thread-suspended',
 			abortController: suspendedAbortController,
 		};
+		const activeTimeout: InstanceAiRunTimeoutDetails = {
+			reason: 'idle_timeout',
+			surface: 'active-run',
+			timeoutMs: 600_000,
+			elapsedMs: 650_000,
+			idleMs: 606_000,
+		};
+		const suspendedTimeout: InstanceAiRunTimeoutDetails = {
+			reason: 'max_lifetime',
+			surface: 'suspended-run',
+			timeoutMs: 1_800_000,
+			elapsedMs: 1_801_000,
+			idleMs: 900_000,
+		};
 
 		runState.sweepTimedOut.mockReturnValue({
 			activeThreadIds: ['thread-active'],
 			suspendedThreadIds: ['thread-suspended'],
 			confirmationRequestIds: ['request-1'],
+			activeTimeouts: { 'thread-active': activeTimeout },
+			suspendedTimeouts: { 'thread-suspended': suspendedTimeout },
 		});
 		runState.cancelActiveRun.mockReturnValue({
 			runId: 'run-active',
@@ -136,7 +159,14 @@ describe('InstanceAiLivenessService', () => {
 			'thread-confirmation',
 			expect.objectContaining({ responseId: 'run-timeout:run-confirmation' }),
 		);
-		expect(service.consumeRunTimedOut('run-active')).toBe(true);
+		expect(service.consumeRunTimeout('run-active')).toEqual({
+			timedOut: true,
+			details: activeTimeout,
+		});
+		expect(service.consumeRunTimeout('run-suspended')).toEqual({
+			timedOut: true,
+			details: suspendedTimeout,
+		});
 		expect(service.hasTimedOutActiveRunThread('thread-active')).toBe(true);
 	});
 
diff --git a/packages/cli/src/modules/instance-ai/__tests__/instance-ai.service.test.ts b/packages/cli/src/modules/instance-ai/__tests__/instance-ai.service.test.ts
index d5ce964e0ab..3135bc15da8 100644
--- a/packages/cli/src/modules/instance-ai/__tests__/instance-ai.service.test.ts
+++ b/packages/cli/src/modules/instance-ai/__tests__/instance-ai.service.test.ts
@@ -533,6 +533,7 @@ type TerminalGuardOrderServiceInternals = {
 		getEventsForRuns: jest.Mock;
 		publish: jest.Mock;
 	};
+	liveness: { consumeRunTimeout: jest.Mock };
 	telemetry: { track: jest.Mock };
 	logger: { warn: jest.Mock; error: jest.Mock };
 	traceContextsByRunId: Map<string, { threadId: string; messageGroupId?: string }>;
@@ -540,6 +541,7 @@ type TerminalGuardOrderServiceInternals = {
 	finalizeRunTracing: jest.Mock;
 	saveAgentTreeSnapshot: jest.Mock;
 	reapAiTemporaryFromRun: jest.Mock;
+	countCreditsIfFirst: jest.Mock;
 	maybeFinalizeRunTraceRoot: jest.Mock;
 	schedulePlannedTasks: jest.Mock;
 	drainPendingCheckpointReentries: jest.Mock;
@@ -602,6 +604,7 @@ function createTerminalGuardOrderService(): TerminalGuardOrderServiceInternals {
 			events.push(event);
 		}),
 	};
+	service.liveness = { consumeRunTimeout: jest.fn(() => ({ timedOut: false })) };
 	service.telemetry = { track: jest.fn() };
 	service.logger = { warn: jest.fn(), error: jest.fn() };
 	service.traceContextsByRunId = new Map([
@@ -611,6 +614,7 @@ function createTerminalGuardOrderService(): TerminalGuardOrderServiceInternals {
 	service.finalizeRunTracing = jest.fn(async () => {});
 	service.saveAgentTreeSnapshot = jest.fn(async () => {});
 	service.reapAiTemporaryFromRun = jest.fn(async () => []);
+	service.countCreditsIfFirst = jest.fn(async () => {});
 	service.maybeFinalizeRunTraceRoot = jest.fn(async () => {});
 	service.schedulePlannedTasks = jest.fn(async () => {});
 	service.drainPendingCheckpointReentries = jest.fn(async () => {});
@@ -1218,6 +1222,10 @@ describe('InstanceAiService — agent tree snapshots', () => {
 });
 
 describe('InstanceAiService — terminal response guard wiring', () => {
+	beforeEach(() => {
+		jest.mocked(resumeAgentRun).mockReset();
+	});
+
 	it('publishes fallback output before run-finish on a silent completed run', () => {
 		const service = createTerminalGuardOrderService();
 
@@ -1294,6 +1302,37 @@ describe('InstanceAiService — terminal response guard wiring', () => {
 		expect(service.eventBus.events.map((event) => event.type)).toEqual(['error', 'run-finish']);
 		expect(service.saveAgentTreeSnapshot).toHaveBeenCalledWith('thread-a', 'run-1', {});
 	});
+
+	it('counts credits when a resumed run completes', async () => {
+		const service = createTerminalGuardOrderService();
+		const abortController = new AbortController();
+		jest.mocked(resumeAgentRun).mockResolvedValueOnce({
+			status: 'completed',
+			mastraRunId: 'mastra-1',
+			text: Promise.resolve('done'),
+			workSummary: { toolCalls: [], totalToolCalls: 0, totalToolErrors: 0 },
+		});
+
+		await service.processResumedStream(
+			{},
+			{},
+			{
+				runId: 'run-1',
+				mastraRunId: 'mastra-1',
+				threadId: 'thread-a',
+				user: fakeUser,
+				toolCallId: 'tool-call-1',
+				signal: abortController.signal,
+				abortController,
+				snapshotStorage: {},
+			},
+		);
+
+		expect(service.countCreditsIfFirst).toHaveBeenCalledWith(fakeUser, 'thread-a', 'run-1');
+		expect(service.telemetry.track).toHaveBeenCalledWith('Builder satisfied user intent', {
+			thread_id: 'thread-a',
+		});
+	});
 });
 
 describe('InstanceAiService — AI temporary workflow cleanup', () => {
diff --git a/packages/cli/src/modules/instance-ai/__tests__/run-trace-metadata.test.ts b/packages/cli/src/modules/instance-ai/__tests__/run-trace-metadata.test.ts
new file mode 100644
index 00000000000..d2449a6e9fc
--- /dev/null
+++ b/packages/cli/src/modules/instance-ai/__tests__/run-trace-metadata.test.ts
@@ -0,0 +1,86 @@
+import type { InstanceAiEvent } from '@n8n/api-types';
+
+import { buildInstanceAiRunTraceMetadata } from '../run-trace-metadata';
+
+const baseEvent = {
+	runId: 'run-1',
+	agentId: 'agent-1',
+};
+
+describe('buildInstanceAiRunTraceMetadata', () => {
+	it('classifies a tool call followed by HITL as a contextless HITL first state', () => {
+		const events: InstanceAiEvent[] = [
+			{
+				type: 'run-start',
+				...baseEvent,
+				payload: { messageId: 'message-1' },
+			},
+			{
+				type: 'tool-call',
+				...baseEvent,
+				payload: { toolCallId: 'tool-1', toolName: 'credentials', args: { action: 'list' } },
+			},
+			{
+				type: 'confirmation-request',
+				...baseEvent,
+				payload: {
+					requestId: 'request-1',
+					toolCallId: 'tool-1',
+					toolName: 'credentials',
+					args: {},
+					severity: 'info',
+					message: 'Pick a credential',
+				},
+			},
+		];
+
+		expect(buildInstanceAiRunTraceMetadata(events, { status: 'cancelled' })).toMatchObject({
+			first_visible_state: 'contextless_hitl',
+			first_tool_name: 'credentials',
+			cancellation_type: 'explicit',
+		});
+	});
+
+	it('keeps the first tool name when assistant text appears first', () => {
+		const events: InstanceAiEvent[] = [
+			{
+				type: 'text-delta',
+				...baseEvent,
+				payload: { text: 'I will check the workflow first.' },
+			},
+			{
+				type: 'tool-call',
+				...baseEvent,
+				payload: { toolCallId: 'tool-1', toolName: 'workflows', args: { action: 'get' } },
+			},
+		];
+
+		expect(buildInstanceAiRunTraceMetadata(events, { status: 'completed' })).toEqual({
+			first_visible_state: 'assistant_text',
+			first_tool_name: 'workflows',
+		});
+	});
+
+	it('records timeout cancellation type and idle tail without extra fields', () => {
+		const metadata = buildInstanceAiRunTraceMetadata([], {
+			status: 'cancelled',
+			cancellationReason: 'timeout',
+			runTimeout: {
+				timedOut: true,
+				details: {
+					reason: 'idle_timeout',
+					surface: 'active-run',
+					timeoutMs: 600_000,
+					elapsedMs: 650_200,
+					idleMs: 606_400.4,
+				},
+			},
+		});
+
+		expect(metadata).toEqual({
+			first_visible_state: 'empty',
+			cancellation_type: 'idle_timeout',
+			idle_tail_ms: 606_400,
+		});
+	});
+});
diff --git a/packages/cli/src/modules/instance-ai/instance-ai.service.ts b/packages/cli/src/modules/instance-ai/instance-ai.service.ts
index b13f9bbb8c6..f2ed7066236 100644
--- a/packages/cli/src/modules/instance-ai/instance-ai.service.ts
+++ b/packages/cli/src/modules/instance-ai/instance-ai.service.ts
@@ -111,7 +111,12 @@ import { InstanceAiCompactionService } from './compaction.service';
 import { ProxyTokenManager } from '@/services/proxy-token-manager';
 import { InstanceAiThreadRepository } from './repositories/instance-ai-thread.repository';
 import { TraceReplayState } from './trace-replay-state';
-import { INSTANCE_AI_RUN_TIMEOUT_REASON, InstanceAiLivenessService } from './liveness';
+import {
+	INSTANCE_AI_RUN_TIMEOUT_REASON,
+	InstanceAiLivenessService,
+	type InstanceAiConsumedRunTimeout,
+} from './liveness';
+import { buildInstanceAiRunTraceMetadata } from './run-trace-metadata';
 
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
@@ -902,6 +907,32 @@ export class InstanceAiService {
 		await this.finalizeMessageTraceRoot(runId, tracing, options);
 	}
 
+	private buildMessageTraceMetadata(
+		threadId: string,
+		runId: string,
+		options: {
+			status: MessageTraceFinalization['status'];
+			cancellationReason?: string;
+			runTimeout?: InstanceAiConsumedRunTimeout;
+		},
+	): Record<string, unknown> {
+		const traceOptions = {
+			status: options.status,
+			...(options.cancellationReason !== undefined
+				? { cancellationReason: options.cancellationReason }
+				: {}),
+			...(options.runTimeout !== undefined ? { runTimeout: options.runTimeout } : {}),
+		};
+
+		return {
+			completion_source: 'orchestrator',
+			...buildInstanceAiRunTraceMetadata(
+				this.eventBus.getEventsForRun(threadId, runId),
+				traceOptions,
+			),
+		};
+	}
+
 	private async finalizeRemainingMessageTraceRoots(
 		threadId: string,
 		options: MessageTraceFinalization,
@@ -1854,7 +1885,9 @@ export class InstanceAiService {
 		return {
 			status: 'error',
 			reason: 'invalid_confirmation_payload',
-			metadata: { completion_source: 'orchestrator' },
+			metadata: this.buildMessageTraceMetadata(args.threadId, args.runId, {
+				status: 'error',
+			}),
 		};
 	}
 
@@ -3123,7 +3156,7 @@ export class InstanceAiService {
 				status: finalStatus,
 				outputText,
 				modelId,
-				metadata: { completion_source: 'orchestrator' },
+				metadata: this.buildMessageTraceMetadata(threadId, runId, { status: finalStatus }),
 			};
 			const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
 				threadId,
@@ -3149,7 +3182,8 @@ export class InstanceAiService {
 			}
 		} catch (error) {
 			if (signal.aborted) {
-				const cancellationReason = this.liveness.consumeRunTimedOut(runId)
+				const runTimeout = this.liveness.consumeRunTimeout(runId);
+				const cancellationReason = runTimeout.timedOut
 					? INSTANCE_AI_RUN_TIMEOUT_REASON
 					: getAbortReason(signal);
 				if (cancellationReason === INSTANCE_AI_RUN_TIMEOUT_REASON) {
@@ -3166,7 +3200,11 @@ export class InstanceAiService {
 				messageTraceFinalization = {
 					status: 'cancelled',
 					reason: cancellationReason,
-					metadata: { completion_source: 'orchestrator' },
+					metadata: this.buildMessageTraceMetadata(threadId, runId, {
+						status: 'cancelled',
+						cancellationReason,
+						runTimeout,
+					}),
 				};
 				const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
 					threadId,
@@ -3206,7 +3244,7 @@ export class InstanceAiService {
 			messageTraceFinalization = {
 				status: 'error',
 				reason: errorMessage,
-				metadata: { completion_source: 'orchestrator' },
+				metadata: this.buildMessageTraceMetadata(threadId, runId, { status: 'error' }),
 			};
 
 			const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
@@ -3237,6 +3275,9 @@ export class InstanceAiService {
 			this.domainAccessTrackersByThread.get(threadId)?.clearRun(runId);
 			if (messageTraceFinalization) {
 				await this.maybeFinalizeRunTraceRoot(runId, messageTraceFinalization);
+				if (messageTraceFinalization.status !== 'cancelled') {
+					this.liveness.consumeRunTimeout(runId);
+				}
 			}
 			// Clean up Mastra workflow snapshots unless the run is suspended (needed for resume).
 			// Mastra only persists snapshots on suspension and never deletes them on completion.
@@ -3700,7 +3741,9 @@ export class InstanceAiService {
 			messageTraceFinalization = {
 				status: finalStatus,
 				outputText,
-				metadata: { completion_source: 'orchestrator' },
+				metadata: this.buildMessageTraceMetadata(opts.threadId, opts.runId, {
+					status: finalStatus,
+				}),
 			};
 			const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
 				opts.threadId,
@@ -3712,6 +3755,7 @@ export class InstanceAiService {
 			});
 
 			if (result.status === 'completed') {
+				await this.countCreditsIfFirst(opts.user, opts.threadId, opts.runId);
 				this.telemetry.track('Builder sent message', {
 					thread_id: opts.threadId,
 					message: outputText,
@@ -3723,17 +3767,28 @@ export class InstanceAiService {
 		} catch (error) {
 			if (opts.signal.aborted) {
 				const messageGroupId = this.traceContextsByRunId.get(opts.runId)?.messageGroupId;
+				const runTimeout = this.liveness.consumeRunTimeout(opts.runId);
+				const cancellationReason = runTimeout.timedOut
+					? INSTANCE_AI_RUN_TIMEOUT_REASON
+					: getAbortReason(opts.signal);
+				if (cancellationReason === INSTANCE_AI_RUN_TIMEOUT_REASON) {
+					this.liveness.publishRunTimeoutNotice(opts.threadId, opts.runId);
+				}
 				this.evaluateTerminalResponse(opts.threadId, opts.runId, 'cancelled', {
 					messageGroupId,
 				});
 				await this.finalizeRunTracing(opts.runId, opts.tracing, {
 					status: 'cancelled',
-					reason: 'user_cancelled',
+					reason: cancellationReason,
 				});
 				messageTraceFinalization = {
 					status: 'cancelled',
-					reason: 'user_cancelled',
-					metadata: { completion_source: 'orchestrator' },
+					reason: cancellationReason,
+					metadata: this.buildMessageTraceMetadata(opts.threadId, opts.runId, {
+						status: 'cancelled',
+						cancellationReason,
+						runTimeout,
+					}),
 				};
 				const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
 					opts.threadId,
@@ -3744,7 +3799,7 @@ export class InstanceAiService {
 					opts.threadId,
 					opts.runId,
 					'cancelled',
-					'user_cancelled',
+					cancellationReason,
 					archivedWorkflowIds,
 				);
 				await this.saveAgentTreeSnapshot(opts.threadId, opts.runId, opts.snapshotStorage);
@@ -3771,7 +3826,9 @@ export class InstanceAiService {
 			messageTraceFinalization = {
 				status: 'error',
 				reason: errorMessage,
-				metadata: { completion_source: 'orchestrator' },
+				metadata: this.buildMessageTraceMetadata(opts.threadId, opts.runId, {
+					status: 'error',
+				}),
 			};
 
 			const archivedWorkflowIds = await this.reapAiTemporaryFromRun(
@@ -3796,6 +3853,9 @@ export class InstanceAiService {
 			// post-run planned-task dispatch.
 			if (messageTraceFinalization) {
 				await this.maybeFinalizeRunTraceRoot(opts.runId, messageTraceFinalization);
+				if (messageTraceFinalization.status !== 'cancelled') {
+					this.liveness.consumeRunTimeout(opts.runId);
+				}
 			}
 			// Post-run planned-task wiring — mirror the executeRun finally.
 			// Resumed ordinary-chat runs also need to drive the scheduler in case
@@ -4137,6 +4197,10 @@ export class InstanceAiService {
 		suspended: SuspendedRunState<User>,
 		reason = 'user_cancelled',
 	): Promise<void> {
+		const runTimeout =
+			reason === INSTANCE_AI_RUN_TIMEOUT_REASON
+				? this.liveness.consumeRunTimeout(suspended.runId)
+				: undefined;
 		if (reason === INSTANCE_AI_RUN_TIMEOUT_REASON) {
 			this.liveness.publishRunTimeoutNotice(suspended.threadId, suspended.runId);
 		}
@@ -4172,7 +4236,11 @@ export class InstanceAiService {
 		await this.maybeFinalizeRunTraceRoot(suspended.runId, {
 			status: 'cancelled',
 			reason,
-			metadata: { completion_source: 'orchestrator' },
+			metadata: this.buildMessageTraceMetadata(suspended.threadId, suspended.runId, {
+				status: 'cancelled',
+				cancellationReason: reason,
+				...(runTimeout ? { runTimeout } : {}),
+			}),
 		});
 	}
 
diff --git a/packages/cli/src/modules/instance-ai/liveness/index.ts b/packages/cli/src/modules/instance-ai/liveness/index.ts
index 23eeb23dd35..92535bc36ba 100644
--- a/packages/cli/src/modules/instance-ai/liveness/index.ts
+++ b/packages/cli/src/modules/instance-ai/liveness/index.ts
@@ -2,6 +2,7 @@ export {
 	INSTANCE_AI_RUN_TIMEOUT_REASON,
 	InstanceAiLivenessService,
 	type InstanceAiLivenessBackgroundTasks,
+	type InstanceAiConsumedRunTimeout,
 	type InstanceAiLivenessEventBus,
 	type InstanceAiLivenessLogger,
 	type InstanceAiLivenessPendingConfirmation,
diff --git a/packages/cli/src/modules/instance-ai/liveness/instance-ai-liveness.service.ts b/packages/cli/src/modules/instance-ai/liveness/instance-ai-liveness.service.ts
index 882639d189f..028455a9c5a 100644
--- a/packages/cli/src/modules/instance-ai/liveness/instance-ai-liveness.service.ts
+++ b/packages/cli/src/modules/instance-ai/liveness/instance-ai-liveness.service.ts
@@ -2,6 +2,8 @@ import type { InstanceAiEvent } from '@n8n/api-types';
 import { Time } from '@n8n/constants';
 import type { InstanceAiLivenessPolicy, InstanceAiLivenessTimeoutReason } from '@n8n/instance-ai';
 
+import type { InstanceAiRunTimeoutDetails } from '../run-timeout-details';
+
 const ORCHESTRATOR_AGENT_ID = 'agent-001';
 
 export const INSTANCE_AI_RUN_TIMEOUT_REASON = 'timeout';
@@ -39,6 +41,14 @@ export type InstanceAiLivenessSweepResult = {
 	activeThreadIds: string[];
 	suspendedThreadIds: string[];
 	confirmationRequestIds: string[];
+	activeTimeouts?: Record<string, InstanceAiRunTimeoutDetails>;
+	suspendedTimeouts?: Record<string, InstanceAiRunTimeoutDetails>;
+	confirmationTimeouts?: Record<string, InstanceAiRunTimeoutDetails>;
+};
+
+export type InstanceAiConsumedRunTimeout = {
+	timedOut: boolean;
+	details?: InstanceAiRunTimeoutDetails;
 };
 
 export type InstanceAiLivenessRunState<
@@ -86,7 +96,7 @@ export class InstanceAiLivenessService<
 > {
 	private timeoutInterval?: NodeJS.Timeout;
 
-	private readonly timedOutRunIds = new Set<string>();
+	private readonly timedOutRunIds = new Map<string, InstanceAiRunTimeoutDetails | undefined>();
 
 	private readonly timedOutActiveRunThreads = new Set<string>();
 
@@ -117,8 +127,8 @@ export class InstanceAiLivenessService<
 		this.timedOutActiveRunThreads.delete(threadId);
 	}
 
-	markRunTimedOut(runId: string): void {
-		this.timedOutRunIds.add(runId);
+	markRunTimedOut(runId: string, details?: InstanceAiRunTimeoutDetails): void {
+		this.timedOutRunIds.set(runId, details);
 	}
 
 	consumeRunTimedOut(runId: string): boolean {
@@ -127,22 +137,37 @@ export class InstanceAiLivenessService<
 		return timedOut;
 	}
 
+	consumeRunTimeout(runId: string): InstanceAiConsumedRunTimeout {
+		const timedOut = this.timedOutRunIds.has(runId);
+		if (!timedOut) return { timedOut: false };
+
+		const details = this.timedOutRunIds.get(runId);
+		this.timedOutRunIds.delete(runId);
+		return details ? { timedOut: true, details } : { timedOut: true };
+	}
+
 	hasTimedOutActiveRunThread(threadId: string): boolean {
 		return this.timedOutActiveRunThreads.has(threadId);
 	}
 
 	async sweepTimedOutWork(now = Date.now()): Promise<void> {
-		const { activeThreadIds, suspendedThreadIds, confirmationRequestIds } =
-			this.options.runState.sweepTimedOut(this.options.policy, now);
+		const {
+			activeThreadIds,
+			suspendedThreadIds,
+			confirmationRequestIds,
+			activeTimeouts,
+			suspendedTimeouts,
+			confirmationTimeouts,
+		} = this.options.runState.sweepTimedOut(this.options.policy, now);
 
 		for (const threadId of activeThreadIds) {
 			this.options.logger.debug('Cancelling timed-out active run', { threadId });
-			this.cancelTimedOutActiveRun(threadId);
+			this.cancelTimedOutActiveRun(threadId, activeTimeouts?.[threadId]);
 		}
 
 		for (const threadId of suspendedThreadIds) {
 			this.options.logger.debug('Auto-rejecting timed-out suspended run', { threadId });
-			this.cancelTimedOutSuspendedRun(threadId);
+			this.cancelTimedOutSuspendedRun(threadId, suspendedTimeouts?.[threadId]);
 		}
 
 		for (const reqId of confirmationRequestIds) {
@@ -152,7 +177,10 @@ export class InstanceAiLivenessService<
 			const pending = this.options.runState.getPendingConfirmation(reqId);
 			if (pending) {
 				const runId = this.options.runState.getActiveRunId(pending.threadId);
-				if (runId) this.publishRunTimeoutNotice(pending.threadId, runId);
+				if (runId) {
+					this.markRunTimedOut(runId, confirmationTimeouts?.[reqId]);
+					this.publishRunTimeoutNotice(pending.threadId, runId);
+				}
 			}
 			this.options.runState.rejectPendingConfirmation(reqId);
 		}
@@ -177,21 +205,21 @@ export class InstanceAiLivenessService<
 		}
 	}
 
-	cancelTimedOutActiveRun(threadId: string): void {
+	cancelTimedOutActiveRun(threadId: string, details?: InstanceAiRunTimeoutDetails): void {
 		const active = this.options.runState.cancelActiveRun(threadId);
 		if (!active) return;
 
-		this.markRunTimedOut(active.runId);
+		this.markRunTimedOut(active.runId, details);
 		this.timedOutActiveRunThreads.add(threadId);
 		this.publishRunTimeoutNotice(threadId, active.runId);
 		active.abortController.abort();
 	}
 
-	cancelTimedOutSuspendedRun(threadId: string): void {
+	cancelTimedOutSuspendedRun(threadId: string, details?: InstanceAiRunTimeoutDetails): void {
 		const suspended = this.options.runState.cancelSuspendedRun(threadId);
 		if (!suspended) return;
 
-		this.markRunTimedOut(suspended.runId);
+		this.markRunTimedOut(suspended.runId, details);
 		suspended.abortController.abort();
 		this.options.finalizeCancelledSuspendedRun(suspended, INSTANCE_AI_RUN_TIMEOUT_REASON);
 	}
diff --git a/packages/cli/src/modules/instance-ai/run-timeout-details.ts b/packages/cli/src/modules/instance-ai/run-timeout-details.ts
new file mode 100644
index 00000000000..14738c59f69
--- /dev/null
+++ b/packages/cli/src/modules/instance-ai/run-timeout-details.ts
@@ -0,0 +1,9 @@
+import type { InstanceAiLivenessSurface, InstanceAiLivenessTimeoutReason } from '@n8n/instance-ai';
+
+export type InstanceAiRunTimeoutDetails = {
+	reason: InstanceAiLivenessTimeoutReason;
+	surface: InstanceAiLivenessSurface;
+	timeoutMs: number;
+	elapsedMs: number;
+	idleMs: number;
+};
diff --git a/packages/cli/src/modules/instance-ai/run-trace-metadata.ts b/packages/cli/src/modules/instance-ai/run-trace-metadata.ts
new file mode 100644
index 00000000000..c4102a2eb91
--- /dev/null
+++ b/packages/cli/src/modules/instance-ai/run-trace-metadata.ts
@@ -0,0 +1,112 @@
+import type { InstanceAiEvent } from '@n8n/api-types';
+import type { InstanceAiLivenessTimeoutReason } from '@n8n/instance-ai';
+
+import type { InstanceAiRunTimeoutDetails } from './run-timeout-details';
+
+const RUN_TIMEOUT_REASON = 'timeout';
+
+export type InstanceAiFirstVisibleState =
+	| 'assistant_text'
+	| 'contextless_hitl'
+	| 'tool_call'
+	| 'task_card'
+	| 'empty';
+
+export type InstanceAiCancellationType = 'explicit' | InstanceAiLivenessTimeoutReason;
+
+export type InstanceAiRunTimeoutTraceContext = {
+	timedOut: boolean;
+	details?: InstanceAiRunTimeoutDetails;
+};
+
+export type InstanceAiRunTraceMetadataOptions = {
+	status: 'completed' | 'cancelled' | 'error';
+	cancellationReason?: string;
+	runTimeout?: InstanceAiRunTimeoutTraceContext;
+};
+
+type FirstVisibleSummary = {
+	state: InstanceAiFirstVisibleState;
+	firstToolName?: string;
+};
+
+function withFirstToolName(
+	state: InstanceAiFirstVisibleState,
+	firstToolName: string | undefined,
+): FirstVisibleSummary {
+	return firstToolName ? { state, firstToolName } : { state };
+}
+
+function getFirstToolName(events: InstanceAiEvent[]): string | undefined {
+	for (const event of events) {
+		if (event.type === 'tool-call') return event.payload.toolName;
+	}
+
+	return undefined;
+}
+
+function getFirstVisibleSummary(events: InstanceAiEvent[]): FirstVisibleSummary {
+	const firstToolName = getFirstToolName(events);
+	let sawToolCall = false;
+
+	for (const event of events) {
+		if (event.type === 'tool-call') {
+			sawToolCall = true;
+			continue;
+		}
+
+		if (event.type === 'confirmation-request') {
+			return {
+				state: 'contextless_hitl',
+				firstToolName: firstToolName ?? event.payload.toolName,
+			};
+		}
+
+		if (event.type === 'text-delta' && event.payload.text.trim().length > 0) {
+			return withFirstToolName('assistant_text', firstToolName);
+		}
+
+		if (event.type === 'agent-spawned' || event.type === 'tasks-update') {
+			return withFirstToolName('task_card', firstToolName);
+		}
+	}
+
+	return withFirstToolName(sawToolCall ? 'tool_call' : 'empty', firstToolName);
+}
+
+function getCancellationType(
+	options: InstanceAiRunTraceMetadataOptions,
+): InstanceAiCancellationType | undefined {
+	if (options.status !== 'cancelled') return undefined;
+
+	if (options.runTimeout?.timedOut || options.cancellationReason === RUN_TIMEOUT_REASON) {
+		return options.runTimeout?.details?.reason ?? 'idle_timeout';
+	}
+
+	return 'explicit';
+}
+
+export function buildInstanceAiRunTraceMetadata(
+	events: InstanceAiEvent[],
+	options: InstanceAiRunTraceMetadataOptions,
+): Record<string, unknown> {
+	const firstVisible = getFirstVisibleSummary(events);
+	const metadata: Record<string, unknown> = {
+		first_visible_state: firstVisible.state,
+	};
+
+	if (firstVisible.firstToolName) {
+		metadata.first_tool_name = firstVisible.firstToolName;
+	}
+
+	const cancellationType = getCancellationType(options);
+	if (cancellationType) {
+		metadata.cancellation_type = cancellationType;
+	}
+
+	if (options.runTimeout?.details?.idleMs !== undefined) {
+		metadata.idle_tail_ms = Math.round(options.runTimeout.details.idleMs);
+	}
+
+	return metadata;
+}
diff --git a/packages/cli/src/modules/mcp/__tests__/mcp-oauth-token.service.test.ts b/packages/cli/src/modules/mcp/__tests__/mcp-oauth-token.service.test.ts
index c76e5e4d53c..f86fcc2e666 100644
--- a/packages/cli/src/modules/mcp/__tests__/mcp-oauth-token.service.test.ts
+++ b/packages/cli/src/modules/mcp/__tests__/mcp-oauth-token.service.test.ts
@@ -261,7 +261,7 @@ describe('McpOAuthTokenService', () => {
 
 			const result = await service.verifyOAuthAccessToken(accessToken);
 
-			expect(result).toEqual({ user });
+			expect(result).toEqual({ user, authType: 'oauth' });
 			expect(userRepository.findOne).toHaveBeenCalledWith({
 				where: { id: userId },
 				relations: ['role'],
diff --git a/packages/cli/src/modules/mcp/__tests__/mcp-server-middleware.service.test.ts b/packages/cli/src/modules/mcp/__tests__/mcp-server-middleware.service.test.ts
index 258dcc21776..6ce1b5e9f28 100644
--- a/packages/cli/src/modules/mcp/__tests__/mcp-server-middleware.service.test.ts
+++ b/packages/cli/src/modules/mcp/__tests__/mcp-server-middleware.service.test.ts
@@ -58,11 +58,11 @@ describe('McpServerMiddlewareService', () => {
 				meta: { isOAuth: true },
 			});
 
-			oauthTokenService.verifyOAuthAccessToken.mockResolvedValue({ user });
+			oauthTokenService.verifyOAuthAccessToken.mockResolvedValue({ user, authType: 'oauth' });
 
 			const result = await service.getUserForToken(oauthToken);
 
-			expect(result).toEqual({ user });
+			expect(result).toEqual({ user, authType: 'oauth' });
 			expect(oauthTokenService.verifyOAuthAccessToken).toHaveBeenCalledWith(oauthToken);
 			expect(mcpServerApiKeyService.verifyApiKey).not.toHaveBeenCalled();
 		});
@@ -74,11 +74,11 @@ describe('McpServerMiddlewareService', () => {
 				aud: 'mcp-server-api',
 			});
 
-			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user });
+			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user, authType: 'api_key' });
 
 			const result = await service.getUserForToken(apiKeyToken);
 
-			expect(result).toEqual({ user });
+			expect(result).toEqual({ user, authType: 'api_key' });
 			expect(mcpServerApiKeyService.verifyApiKey).toHaveBeenCalledWith(apiKeyToken);
 			expect(oauthTokenService.verifyOAuthAccessToken).not.toHaveBeenCalled();
 		});
@@ -91,11 +91,11 @@ describe('McpServerMiddlewareService', () => {
 				meta: { isOAuth: false },
 			});
 
-			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user });
+			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user, authType: 'api_key' });
 
 			const result = await service.getUserForToken(apiKeyToken);
 
-			expect(result).toEqual({ user });
+			expect(result).toEqual({ user, authType: 'api_key' });
 			expect(mcpServerApiKeyService.verifyApiKey).toHaveBeenCalledWith(apiKeyToken);
 			expect(oauthTokenService.verifyOAuthAccessToken).not.toHaveBeenCalled();
 		});
@@ -234,13 +234,15 @@ describe('McpServerMiddlewareService', () => {
 			const res = mockDeep<Response>();
 			const next = jest.fn() as NextFunction;
 
-			oauthTokenService.verifyOAuthAccessToken.mockResolvedValue({ user });
+			oauthTokenService.verifyOAuthAccessToken.mockResolvedValue({ user, authType: 'oauth' });
 
 			const middleware = service.getAuthMiddleware();
 
 			await middleware(req, res, next);
+			const authenticatedReq = req as Request & { user?: User; mcpAuthType?: 'oauth' };
 
-			expect((req as any).user).toEqual(user);
+			expect(authenticatedReq.user).toEqual(user);
+			expect(authenticatedReq.mcpAuthType).toBe('oauth');
 			expect(next).toHaveBeenCalled();
 			expect(res.status).not.toHaveBeenCalled();
 		});
@@ -256,13 +258,15 @@ describe('McpServerMiddlewareService', () => {
 			const res = mockDeep<Response>();
 			const next = jest.fn() as NextFunction;
 
-			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user });
+			mcpServerApiKeyService.verifyApiKey.mockResolvedValue({ user, authType: 'api_key' });
 
 			const middleware = service.getAuthMiddleware();
 
 			await middleware(req, res, next);
+			const authenticatedReq = req as Request & { user?: User; mcpAuthType?: 'api_key' };
 
-			expect((req as any).user).toEqual(user);
+			expect(authenticatedReq.user).toEqual(user);
+			expect(authenticatedReq.mcpAuthType).toBe('api_key');
 			expect(next).toHaveBeenCalled();
 			expect(res.status).not.toHaveBeenCalled();
 		});
diff --git a/packages/cli/src/modules/mcp/__tests__/mcp.controller.test.ts b/packages/cli/src/modules/mcp/__tests__/mcp.controller.test.ts
index 91c28664ef1..15c0ae1952c 100644
--- a/packages/cli/src/modules/mcp/__tests__/mcp.controller.test.ts
+++ b/packages/cli/src/modules/mcp/__tests__/mcp.controller.test.ts
@@ -19,6 +19,8 @@ Container.set(McpServerMiddlewareService, mcpServerMiddlewareService);
 import { McpController, type FlushableResponse } from '../mcp.controller';
 import { McpService } from '../mcp.service';
 import { McpSettingsService } from '../mcp.settings.service';
+import { Telemetry } from '@/telemetry';
+import type { UserConnectedToMCPEventPayload } from '../mcp.types';
 
 const mockHandleRequest = jest.fn().mockResolvedValue(undefined);
 jest.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => {
@@ -29,8 +31,12 @@ jest.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => {
 	return { StreamableHTTPServerTransport };
 });
 
-const createReq = (overrides: Partial<AuthenticatedRequest> = {}): AuthenticatedRequest =>
-	({ user: { id: 'user-1' }, body: {}, ...overrides }) as unknown as AuthenticatedRequest;
+type AuthenticatedMcpRequest = AuthenticatedRequest & {
+	mcpAuthType?: UserConnectedToMCPEventPayload['auth_type'];
+};
+
+const createReq = (overrides: Partial<AuthenticatedMcpRequest> = {}): AuthenticatedMcpRequest =>
+	({ user: { id: 'user-1' }, body: {}, ...overrides }) as unknown as AuthenticatedMcpRequest;
 
 const createRes = (): FlushableResponse => {
 	const res = mock<FlushableResponse>();
@@ -42,6 +48,7 @@ const createRes = (): FlushableResponse => {
 describe('McpController', () => {
 	let controller: McpController;
 	const logger = mock<Logger>();
+	const telemetry = { track: jest.fn() } as unknown as Telemetry;
 	const mcpService = { getServer: jest.fn() } as unknown as McpService;
 	const mcpSettingsService = { getEnabled: jest.fn() } as unknown as McpSettingsService;
 
@@ -49,6 +56,7 @@ describe('McpController', () => {
 		jest.clearAllMocks();
 
 		Container.set(Logger, logger);
+		Container.set(Telemetry, telemetry);
 		Container.set(McpService, mcpService);
 		Container.set(McpSettingsService, mcpSettingsService);
 
@@ -75,6 +83,35 @@ describe('McpController', () => {
 		expect(mcpService.getServer as unknown as jest.Mock).toHaveBeenCalled();
 	});
 
+	test('tracks successful initialize connections with auth type', async () => {
+		(mcpSettingsService.getEnabled as jest.Mock).mockResolvedValue(true);
+		(mcpService.getServer as unknown as jest.Mock).mockReturnValue({
+			connect: jest.fn().mockResolvedValue(undefined),
+			close: jest.fn().mockResolvedValue(undefined),
+		});
+		const res = createRes();
+
+		await controller.build(
+			createReq({
+				mcpAuthType: 'oauth',
+				body: {
+					jsonrpc: '2.0',
+					method: 'initialize',
+					params: { clientInfo: { name: 'Claude', version: '1.0.0' } },
+				},
+			}),
+			res,
+		);
+
+		expect(telemetry.track).toHaveBeenCalledWith('User connected to MCP server', {
+			user_id: 'user-1',
+			client_name: 'Claude',
+			client_version: '1.0.0',
+			auth_type: 'oauth',
+			mcp_connection_status: 'success',
+		});
+	});
+
 	test('HEAD /http returns 401 with WWW-Authenticate header for auth scheme discovery', async () => {
 		const req = {} as Request;
 		const res = createRes();
diff --git a/packages/cli/src/modules/mcp/mcp-api-key.service.ts b/packages/cli/src/modules/mcp/mcp-api-key.service.ts
index 92cb64b25d7..3b89012cf80 100644
--- a/packages/cli/src/modules/mcp/mcp-api-key.service.ts
+++ b/packages/cli/src/modules/mcp/mcp-api-key.service.ts
@@ -78,6 +78,7 @@ export class McpServerApiKeyService {
 				return {
 					user: tokenGrant.actor ?? tokenGrant.subject,
 					actor: tokenGrant.actor,
+					authType: 'api_key',
 				};
 			}
 
diff --git a/packages/cli/src/modules/mcp/mcp-oauth-token.service.ts b/packages/cli/src/modules/mcp/mcp-oauth-token.service.ts
index 4907820f8d2..496997c4988 100644
--- a/packages/cli/src/modules/mcp/mcp-oauth-token.service.ts
+++ b/packages/cli/src/modules/mcp/mcp-oauth-token.service.ts
@@ -188,7 +188,7 @@ export class McpOAuthTokenService {
 				return { user: null, context: { reason: 'user_not_found', auth_type: 'oauth' } };
 			}
 
-			return { user };
+			return { user, authType: 'oauth' };
 		} catch (error) {
 			const errorForSure = ensureError(error);
 			const reason =
diff --git a/packages/cli/src/modules/mcp/mcp-server-middleware.service.ts b/packages/cli/src/modules/mcp/mcp-server-middleware.service.ts
index 34cccfa4dde..c2d7d503528 100644
--- a/packages/cli/src/modules/mcp/mcp-server-middleware.service.ts
+++ b/packages/cli/src/modules/mcp/mcp-server-middleware.service.ts
@@ -92,6 +92,8 @@ export class McpServerMiddlewareService {
 			}
 
 			(req as AuthenticatedRequest).user = user;
+			(req as AuthenticatedRequest & { mcpAuthType?: UserWithContext['authType'] }).mcpAuthType =
+				result.authType;
 
 			next();
 		};
diff --git a/packages/cli/src/modules/mcp/mcp.controller.ts b/packages/cli/src/modules/mcp/mcp.controller.ts
index 16e4abc4459..b457f8bc138 100644
--- a/packages/cli/src/modules/mcp/mcp.controller.ts
+++ b/packages/cli/src/modules/mcp/mcp.controller.ts
@@ -123,6 +123,9 @@ export class McpController {
 			user_id: req.user.id,
 			client_name: clientInfo?.name,
 			client_version: clientInfo?.version,
+			auth_type: (
+				req as AuthenticatedRequest & { mcpAuthType?: UserConnectedToMCPEventPayload['auth_type'] }
+			).mcpAuthType,
 		};
 
 		// Deny if MCP access is disabled
diff --git a/packages/cli/src/modules/mcp/mcp.types.ts b/packages/cli/src/modules/mcp/mcp.types.ts
index f4896ceb71a..9ca20a7a2c4 100644
--- a/packages/cli/src/modules/mcp/mcp.types.ts
+++ b/packages/cli/src/modules/mcp/mcp.types.ts
@@ -71,6 +71,7 @@ export type UserConnectedToMCPEventPayload = {
 	user_id?: string;
 	client_name?: string;
 	client_version?: string;
+	auth_type?: Mcpauth_type;
 	mcp_connection_status: 'success' | 'error';
 	error?: string;
 };
@@ -128,4 +129,5 @@ export type UserWithContext = {
 	user: User | null;
 	actor?: User;
 	context?: TelemetryAuthContext;
+	authType?: Mcpauth_type;
 };
diff --git a/packages/cli/src/modules/source-control.ee/__tests__/source-control-import.service.ee.test.ts b/packages/cli/src/modules/source-control.ee/__tests__/source-control-import.service.ee.test.ts
index de39fbd0788..31526404a35 100644
--- a/packages/cli/src/modules/source-control.ee/__tests__/source-control-import.service.ee.test.ts
+++ b/packages/cli/src/modules/source-control.ee/__tests__/source-control-import.service.ee.test.ts
@@ -2746,7 +2746,7 @@ describe('SourceControlImportService', () => {
 					id: 'dt1',
 					name: 'Test Table 1',
 					projectId: 'project1',
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -2754,7 +2754,7 @@ describe('SourceControlImportService', () => {
 					id: 'dt2',
 					name: 'Test Table 2',
 					projectId: 'project2',
-					columns: [{ id: 'col2', name: 'Column 2', type: 'number', index: 0 }],
+					columns: [{ id: 'col2', name: 'Column2', type: 'number', index: 0 }],
 					createdAt: '2024-01-03T00:00:00.000Z',
 					updatedAt: '2024-01-04T00:00:00.000Z',
 				};
@@ -2824,7 +2824,7 @@ describe('SourceControlImportService', () => {
 						id: 'dt1',
 						name: 'Test Table',
 						projectId: 'project1',
-						columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+						columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 						createdAt: new Date('2024-01-01'),
 						updatedAt: new Date('2024-01-02'),
 						project: {
@@ -2851,7 +2851,7 @@ describe('SourceControlImportService', () => {
 						projectId: 'project1',
 						projectName: 'Team Project 1',
 					},
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					filename: expect.stringContaining('dt1.json'),
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
@@ -2960,7 +2960,7 @@ describe('SourceControlImportService', () => {
 						teamId: 'project1',
 						teamName: 'Team Project 1',
 					},
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -3003,7 +3003,7 @@ describe('SourceControlImportService', () => {
 						projectName: 'User Name',
 						personalEmail: 'user@example.com',
 					},
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -3041,8 +3041,8 @@ describe('SourceControlImportService', () => {
 						teamName: 'Team Project 1',
 					},
 					columns: [
-						{ id: 'col1', name: 'Column 1', type: 'string', index: 0 },
-						{ id: 'col2', name: 'Column 2', type: 'number', index: 1 },
+						{ id: 'col1', name: 'Column1', type: 'string', index: 0 },
+						{ id: 'col2', name: 'Column2', type: 'number', index: 1 },
 					],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
@@ -3052,12 +3052,12 @@ describe('SourceControlImportService', () => {
 					id: 'dt1',
 					name: 'Old Name',
 					projectId: 'project1',
-					columns: [{ id: 'col1', name: 'Column 1' }],
+					columns: [{ id: 'col1', name: 'Column1' }],
 				};
 
 				fsReadFile.mockResolvedValue(JSON.stringify(mockDataTable) as any);
 				dataTableRepository.findOne.mockResolvedValue(existingTable as any);
-				dataTableColumnRepository.find.mockResolvedValue([{ id: 'col1', name: 'Column 1' }] as any);
+				dataTableColumnRepository.find.mockResolvedValue([{ id: 'col1', name: 'Column1' }] as any);
 				dataTableColumnRepository.save.mockImplementation(async (col: any) => col);
 				projectRepository.findOne.mockResolvedValue({ id: 'project1', type: 'team' } as any);
 
@@ -3126,7 +3126,7 @@ describe('SourceControlImportService', () => {
 						teamId: 'project1',
 						teamName: 'Team Project 1',
 					},
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -3136,16 +3136,16 @@ describe('SourceControlImportService', () => {
 					name: 'Test Table',
 					projectId: 'project1',
 					columns: [
-						{ id: 'col1', name: 'Column 1' },
-						{ id: 'col2', name: 'Column 2' },
+						{ id: 'col1', name: 'Column1' },
+						{ id: 'col2', name: 'Column2' },
 					],
 				};
 
 				fsReadFile.mockResolvedValue(JSON.stringify(mockDataTable) as any);
 				dataTableRepository.findOne.mockResolvedValue(existingTable as any);
 				dataTableColumnRepository.find.mockResolvedValue([
-					{ id: 'col1', name: 'Column 1' },
-					{ id: 'col2', name: 'Column 2' },
+					{ id: 'col1', name: 'Column1' },
+					{ id: 'col2', name: 'Column2' },
 				] as any);
 				dataTableColumnRepository.save.mockResolvedValue({ id: 'col1' } as any);
 				projectRepository.findOne.mockResolvedValue({ id: 'project1', type: 'team' } as any);
@@ -3156,7 +3156,7 @@ describe('SourceControlImportService', () => {
 				// Assert
 				expect(dataTableDDLService.dropColumnFromTable).toHaveBeenCalledWith(
 					'dt1',
-					'Column 2',
+					'Column2',
 					'sqlite',
 					expect.anything(),
 				);
@@ -3183,7 +3183,7 @@ describe('SourceControlImportService', () => {
 						teamId: 'project1',
 						teamName: 'Team Project 1',
 					},
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -3204,13 +3204,81 @@ describe('SourceControlImportService', () => {
 				expect(dataTableRepository.upsert).not.toHaveBeenCalled();
 			});
 
+			it('should skip columns with invalid names', async () => {
+				// Arrange
+				const mockDataTable = {
+					id: 'dt1',
+					name: 'Test Table',
+					ownedBy: {
+						type: 'team',
+						teamId: 'project1',
+						teamName: 'Team Project 1',
+					},
+					columns: [
+						{ id: 'col1', name: 'validName', type: 'string', index: 0 },
+						{
+							id: 'col2',
+							name: 'invalid" text); create INVALID table; --',
+							type: 'string',
+							index: 1,
+						},
+					],
+					createdAt: '2024-01-01T00:00:00.000Z',
+					updatedAt: '2024-01-02T00:00:00.000Z',
+				};
+
+				fsReadFile.mockResolvedValue(JSON.stringify(mockDataTable) as any);
+				dataTableRepository.findOne.mockResolvedValue(null);
+				dataTableColumnRepository.find.mockResolvedValue([]);
+				dataTableColumnRepository.save.mockImplementation(async (col: any) => col);
+				projectRepository.findOne.mockResolvedValue({ id: 'project1', type: 'team' } as any);
+
+				// Act
+				await service.importDataTablesFromWorkFolder([mockCandidate], mockUser.id);
+
+				// Assert
+				expect(dataTableDDLService.createTableWithColumns).toHaveBeenCalledWith(
+					'dt1',
+					expect.arrayContaining([expect.objectContaining({ id: 'col1', name: 'validName' })]),
+					expect.anything(),
+				);
+				const columns = (dataTableDDLService.createTableWithColumns as jest.Mock).mock.calls[0][1];
+				expect(columns).not.toEqual(
+					expect.arrayContaining([expect.objectContaining({ id: 'col2' })]),
+				);
+			});
+
+			it('should skip data tables with invalid IDs', async () => {
+				// Arrange
+				const mockDataTable = {
+					id: 'invalid"; create INVALID table;--',
+					name: 'Test Table',
+					ownedBy: {
+						type: 'team',
+						teamId: 'project1',
+						teamName: 'Team Project 1',
+					},
+					columns: [{ id: 'col1', name: 'validName', type: 'string', index: 0 }],
+					createdAt: '2024-01-01T00:00:00.000Z',
+					updatedAt: '2024-01-02T00:00:00.000Z',
+				};
+
+				fsReadFile.mockResolvedValue(JSON.stringify(mockDataTable) as any);
+
+				// Act
+				await service.importDataTablesFromWorkFolder([mockCandidate], mockUser.id);
+
+				// Assert
+				expect(dataTableRepository.upsert).not.toHaveBeenCalled();
+			});
+
 			it('should not partially import when a name collision exists among multiple tables', async () => {
 				// Arrange — two tables: dt1 is valid, dt2 has a name collision
 				const validTable = {
 					id: 'dt1',
 					name: 'Valid Table',
 					ownedBy: { type: 'team', teamId: 'project1', teamName: 'Team Project 1' },
-					columns: [{ id: 'col1', name: 'Column 1', type: 'string', index: 0 }],
+					columns: [{ id: 'col1', name: 'Column1', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
@@ -3218,7 +3286,7 @@ describe('SourceControlImportService', () => {
 					id: 'dt2',
 					name: 'Colliding Table',
 					ownedBy: { type: 'team', teamId: 'project1', teamName: 'Team Project 1' },
-					columns: [{ id: 'col2', name: 'Column 2', type: 'string', index: 0 }],
+					columns: [{ id: 'col2', name: 'Column2', type: 'string', index: 0 }],
 					createdAt: '2024-01-01T00:00:00.000Z',
 					updatedAt: '2024-01-02T00:00:00.000Z',
 				};
diff --git a/packages/cli/src/modules/source-control.ee/source-control-import.service.ee.ts b/packages/cli/src/modules/source-control.ee/source-control-import.service.ee.ts
index 1aedd9785cd..6e14f4ce1a5 100644
--- a/packages/cli/src/modules/source-control.ee/source-control-import.service.ee.ts
+++ b/packages/cli/src/modules/source-control.ee/source-control-import.service.ee.ts
@@ -46,6 +46,7 @@ import { DataTableColumn } from '@/modules/data-table/data-table-column.entity';
 import { DataTableColumnRepository } from '@/modules/data-table/data-table-column.repository';
 import { DataTableDDLService } from '@/modules/data-table/data-table-ddl.service';
 import { DataTableRepository } from '@/modules/data-table/data-table.repository';
+import { isValidColumnName, isValidDataTableId } from '@/modules/data-table/utils/sql-utils';
 import { RedactionEnforcementService } from '@/modules/redaction/redaction-enforcement.service';
 import { isUniqueConstraintError } from '@/response-helper';
 import { TagService } from '@/services/tag.service';
@@ -1239,6 +1240,13 @@ export class SourceControlImportService {
 				continue;
 			}
 
+			if (!isValidDataTableId(dataTable.id)) {
+				this.logger.warn(
+					`Invalid data table ID "${dataTable.id}" in file ${candidate.file}. Skipping.`,
+				);
+				continue;
+			}
+
 			let targetProject: Project | null = null;
 
 			if (dataTable.ownedBy) {
@@ -1354,6 +1362,13 @@ export class SourceControlImportService {
 					// Upsert columns
 					const columnEntities = [];
 					for (const column of dataTable.columns) {
+						if (!isValidColumnName(column.name)) {
+							this.logger.warn(
+								`Invalid column name "${column.name}" in data table ${dataTable.name}. Skipping column.`,
+							);
+							continue;
+						}
+
 						if (!isValidDataTableColumnType(column.type)) {
 							this.logger.warn(
 								`Invalid column type "${column.type}" in data table ${dataTable.name}, column ${column.name}. Skipping column.`,
diff --git a/packages/cli/src/oauth/__tests__/oauth.service.test.ts b/packages/cli/src/oauth/__tests__/oauth.service.test.ts
index 9fa6413d69f..fc86a206478 100644
--- a/packages/cli/src/oauth/__tests__/oauth.service.test.ts
+++ b/packages/cli/src/oauth/__tests__/oauth.service.test.ts
@@ -136,7 +136,7 @@ describe('OauthService', () => {
 				enumerable: true,
 			});
 
-			const promise = service.getCredential(req);
+			const promise = service.getCredentialForUpdate(req);
 			await expect(promise).rejects.toThrow(BadRequestError);
 			await expect(promise).rejects.toThrow('Required credential ID is missing');
 		});
@@ -149,10 +149,10 @@ describe('OauthService', () => {
 
 			credentialsFinderService.findCredentialForUser.mockResolvedValue(null);
 
-			await expect(service.getCredential(req)).rejects.toThrow(NotFoundError);
+			await expect(service.getCredentialForUpdate(req)).rejects.toThrow(NotFoundError);
 			expect(logger.error).toHaveBeenCalledWith(
 				'OAuth credential authorization failed because the current user does not have the correct permissions',
-				{ userId: '123' },
+				{ userId: '123', credentialId: 'credential-id' },
 			);
 		});
 
@@ -165,13 +165,13 @@ describe('OauthService', () => {
 
 			credentialsFinderService.findCredentialForUser.mockResolvedValue(mockCredential);
 
-			const result = await service.getCredential(req);
+			const result = await service.getCredentialForUpdate(req);
 
 			expect(result).toBe(mockCredential);
 			expect(credentialsFinderService.findCredentialForUser).toHaveBeenCalledWith(
 				'credential-id',
 				req.user,
-				['credential:read'],
+				['credential:update'],
 			);
 		});
 	});
@@ -404,20 +404,28 @@ describe('OauthService', () => {
 			};
 			const encodedState = Buffer.from(JSON.stringify(state)).toString('base64');
 			cipher.decryptV2.mockResolvedValue(JSON.stringify(csrfData));
+			const mockCredential = mock<CredentialsEntity>({ id: 'credential-id' });
+			credentialsFinderService.findCredentialForUser.mockResolvedValue(mockCredential);
 			const req = mock<AuthenticatedRequest>({
 				user: mock<User>({ id: 'user-id' }),
 			});
 
-			const result = await (service as any).decodeCsrfState(encodedState, req);
+			const [decodedState, credential] = await (service as any).decodeCsrfState(encodedState, req);
 
 			expect(cipher.decryptV2).toHaveBeenCalledWith('encrypted-data');
-			expect(result).toMatchObject({
+			expect(decodedState).toMatchObject({
 				token: 'token',
 				createdAt: timestamp,
 				cid: 'credential-id',
 				userId: 'user-id',
 				origin: 'static-credential',
 			});
+			expect(credential).toBe(mockCredential);
+			expect(credentialsFinderService.findCredentialForUser).toHaveBeenCalledWith(
+				'credential-id',
+				req.user,
+				['credential:update'],
+			);
 		});
 
 		it('should throw error when state format is invalid', async () => {
@@ -529,20 +537,24 @@ describe('OauthService', () => {
 			};
 			const encodedState = Buffer.from(JSON.stringify(state)).toString('base64');
 			cipher.decryptV2.mockResolvedValue(JSON.stringify(csrfData));
+			const mockCredential = mock<CredentialsEntity>({ id: 'credential-id' });
+			credentialsRepository.findOneBy.mockResolvedValue(mockCredential as any);
 			const req = mock<AuthenticatedRequest>({
 				user: mock<User>({ id: 'user-id' }),
 			});
 
-			const result = await (service as any).decodeCsrfState(encodedState, req);
+			const [decodedState, credential] = await (service as any).decodeCsrfState(encodedState, req);
 
-			expect(result).toMatchObject({
+			expect(decodedState).toMatchObject({
 				token: 'token',
 				createdAt: timestamp,
 				cid: 'credential-id',
 				userId: 'different-user-id',
 				origin: 'dynamic-credential',
 			});
+			expect(credential).toBe(mockCredential);
 			expect(cipher.decryptV2).toHaveBeenCalledWith('encrypted-data');
+			expect(credentialsFinderService.findCredentialForUser).not.toHaveBeenCalled();
 		});
 
 		it('should bypass user validation for dynamic-credential origin even when req.user is undefined', async () => {
@@ -558,19 +570,22 @@ describe('OauthService', () => {
 			};
 			const encodedState = Buffer.from(JSON.stringify(state)).toString('base64');
 			cipher.decryptV2.mockResolvedValue(JSON.stringify(csrfData));
+			const mockCredential = mock<CredentialsEntity>({ id: 'credential-id' });
+			credentialsRepository.findOneBy.mockResolvedValue(mockCredential as any);
 			const req = mock<AuthenticatedRequest>({
 				user: undefined,
 			});
 
-			const result = await (service as any).decodeCsrfState(encodedState, req);
+			const [decodedState, credential] = await (service as any).decodeCsrfState(encodedState, req);
 
-			expect(result).toMatchObject({
+			expect(decodedState).toMatchObject({
 				token: 'token',
 				createdAt: timestamp,
 				cid: 'credential-id',
 				userId: 'user-id',
 				origin: 'dynamic-credential',
 			});
+			expect(credential).toBe(mockCredential);
 			expect(cipher.decryptV2).toHaveBeenCalledWith('encrypted-data');
 		});
 
@@ -760,7 +775,7 @@ describe('OauthService', () => {
 			});
 
 			cipher.decryptV2.mockResolvedValue(JSON.stringify(csrfData));
-			credentialsRepository.findOneBy.mockResolvedValue(mockCredential);
+			credentialsFinderService.findCredentialForUser.mockResolvedValue(mockCredential);
 			jest.mocked(WorkflowExecuteAdditionalData.getBase).mockResolvedValue(mockAdditionalData);
 			credentialsHelper.getDecrypted.mockResolvedValue(mockDecryptedData);
 			credentialsHelper.applyDefaultsAndOverwrites.mockResolvedValue(mockOAuthCredentials);
@@ -781,7 +796,7 @@ describe('OauthService', () => {
 			});
 		});
 
-		it('should throw UnexpectedError when credential is not found', async () => {
+		it('should throw NotFoundError when credential is not found', async () => {
 			const csrfData = {
 				cid: 'credential-id',
 				userId: 'user-id',
@@ -800,12 +815,10 @@ describe('OauthService', () => {
 				user: mock<User>({ id: 'user-id' }),
 			});
 
-			credentialsRepository.findOneBy.mockResolvedValue(null);
+			credentialsFinderService.findCredentialForUser.mockResolvedValue(null);
 
-			await expect(service.resolveCredential(req)).rejects.toThrow(UnexpectedError);
-			await expect(service.resolveCredential(req)).rejects.toThrow(
-				'OAuth callback failed because of insufficient permissions',
-			);
+			await expect(service.resolveCredential(req)).rejects.toThrow(NotFoundError);
+			await expect(service.resolveCredential(req)).rejects.toThrow('Credential not found');
 		});
 
 		it('should throw UnexpectedError when CSRF state is invalid', async () => {
@@ -832,7 +845,7 @@ describe('OauthService', () => {
 				user: mock<User>({ id: 'user-id' }),
 			});
 
-			credentialsRepository.findOneBy.mockResolvedValue(mockCredential);
+			credentialsFinderService.findCredentialForUser.mockResolvedValue(mockCredential);
 			jest.mocked(WorkflowExecuteAdditionalData.getBase).mockResolvedValue(mockAdditionalData);
 			credentialsHelper.getDecrypted.mockResolvedValue(mockDecryptedData);
 			credentialsHelper.applyDefaultsAndOverwrites.mockResolvedValue(mockOAuthCredentials);
diff --git a/packages/cli/src/oauth/oauth.service.ts b/packages/cli/src/oauth/oauth.service.ts
index aea2562ed13..3e22f86fcb3 100644
--- a/packages/cli/src/oauth/oauth.service.ts
+++ b/packages/cli/src/oauth/oauth.service.ts
@@ -90,7 +90,7 @@ export class OauthService {
 		return `${restUrl}/oauth${oauthVersion}-credential`;
 	}
 
-	async getCredential(
+	async getCredentialForUpdate(
 		req: OAuthRequest.OAuth1Credential.Auth | OAuthRequest.OAuth2Credential.Auth,
 	): Promise<CredentialsEntity> {
 		const { id: credentialId } = req.query;
@@ -102,13 +102,13 @@ export class OauthService {
 		const credential = await this.credentialsFinderService.findCredentialForUser(
 			credentialId,
 			req.user,
-			['credential:read'],
+			['credential:update'],
 		);
 
 		if (!credential) {
 			this.logger.error(
 				'OAuth credential authorization failed because the current user does not have the correct permissions',
-				{ userId: req.user.id },
+				{ userId: req.user.id, credentialId },
 			);
 			throw new NotFoundError(RESPONSE_ERROR_MESSAGES.NO_CREDENTIAL);
 		}
@@ -250,7 +250,7 @@ export class OauthService {
 	protected async decodeCsrfState(
 		encodedState: string,
 		req: AuthenticatedRequest,
-	): Promise<CsrfState & CreateCsrfStateData> {
+	): Promise<[CsrfState & CreateCsrfStateData, CredentialsEntity | null]> {
 		const errorMessage = 'Invalid state format';
 		const decodedState = Buffer.from(encodedState, 'base64').toString();
 		const decoded = jsonParse<CsrfState>(decodedState, {
@@ -270,28 +270,31 @@ export class OauthService {
 
 		// Dynamic credentials: skip user validation (e.g. embed/iframe flows) as they do not contain an n8n user
 		if (decryptedState.origin === 'dynamic-credential') {
-			return {
-				...decoded,
-				...decryptedState,
-			};
+			return [
+				{ ...decoded, ...decryptedState },
+				await this.getCredentialWithoutUser(decryptedState.cid),
+			];
 		}
 
 		// Static credentials: skip user validation only when N8N_SKIP_AUTH_ON_OAUTH_CALLBACK is true (e.g. embed/iframe)
 		if (skipAuthOnOAuthCallback) {
-			return {
-				...decoded,
-				...decryptedState,
-			};
+			return [
+				{ ...decoded, ...decryptedState },
+				await this.getCredentialWithoutUser(decryptedState.cid),
+			];
 		}
 
 		if (req.user?.id === undefined || decryptedState.userId !== req.user.id) {
 			throw new AuthError('Unauthorized');
 		}
 
-		return {
-			...decoded,
-			...decryptedState,
-		};
+		const credential = await this.credentialsFinderService.findCredentialForUser(
+			decryptedState.cid,
+			req.user,
+			['credential:update'],
+		);
+
+		return [{ ...decoded, ...decryptedState }, credential];
 	}
 
 	protected verifyCsrfState(
@@ -313,10 +316,9 @@ export class OauthService {
 		[CredentialsEntity, ICredentialDataDecryptedObject, T, CsrfState & CreateCsrfStateData]
 	> {
 		const { state: encodedState } = req.query;
-		const state = await this.decodeCsrfState(encodedState, req);
-		const credential = await this.getCredentialWithoutUser(state.cid);
+		const [state, credential] = await this.decodeCsrfState(encodedState, req);
 		if (!credential) {
-			throw new UnexpectedError('OAuth callback failed because of insufficient permissions');
+			throw new NotFoundError(RESPONSE_ERROR_MESSAGES.NO_CREDENTIAL);
 		}
 
 		const additionalData = await this.getAdditionalData();
diff --git a/packages/cli/src/services/__tests__/export.service.test.ts b/packages/cli/src/services/__tests__/export.service.test.ts
index 8fc34be8c67..eb72c54a42f 100644
--- a/packages/cli/src/services/__tests__/export.service.test.ts
+++ b/packages/cli/src/services/__tests__/export.service.test.ts
@@ -3,6 +3,7 @@ import { ExportService } from '../export.service';
 import { type DataSource } from '@n8n/typeorm';
 import { mkdir, rm, readdir, appendFile, readFile } from 'fs/promises';
 import { mock } from 'jest-mock-extended';
+import type * as JestMockExtended from 'jest-mock-extended';
 import type { Cipher } from 'n8n-core';
 
 // Mock fs/promises with proper implementations
@@ -25,9 +26,16 @@ jest.mock('@/utils/validate-database-type', () => ({
 }));
 
 // Mock @n8n/db
-jest.mock('@n8n/db', () => ({
-	DataSource: mock<DataSource>(),
-}));
+jest.mock('@n8n/db', () => {
+	// `mock` from jest-mock-extended is not yet initialised when this hoisted
+	// factory runs, so resolve it lazily via require.
+	const jestMockExtended = require('jest-mock-extended') as typeof JestMockExtended;
+	return {
+		DataSource: jestMockExtended.mock<DataSource>(),
+		// `sql-utils` imports `DslColumn`; provide a no-op so the import resolves.
+		DslColumn: class {},
+	};
+});
 
 describe('ExportService', () => {
 	let exportService: ExportService;
@@ -182,7 +190,7 @@ describe('ExportService', () => {
 
 			await exportService.exportEntities(outputDir);
 
-			expect(mockDataSource.query).toHaveBeenCalledTimes(5); // 1 migrations + 3 entity queries
+			expect(mockDataSource.query).toHaveBeenCalledTimes(6); // 2 migrations + 1 data_table + 3 entity queries
 			expect(appendFile).toHaveBeenCalled();
 		});
 
@@ -210,10 +218,34 @@ describe('ExportService', () => {
 
 			await exportService.exportEntities(outputDir, new Set(['execution_data']));
 
-			expect(mockDataSource.query).toHaveBeenCalledTimes(4); // 1 migrations + 3 entity queries
+			expect(mockDataSource.query).toHaveBeenCalledTimes(5); // 2 migrations + 1 data_table + 2 entity queries
 			expect(appendFile).toHaveBeenCalled();
 		});
 
+		it('should skip data-table row export when includeDataTableRows is false', async () => {
+			const outputDir = '/test/output';
+
+			jest.mocked(mockDataSource.query).mockImplementation(async () => []);
+			jest.mocked(readdir).mockResolvedValue([]);
+
+			await exportService.exportEntities(outputDir, undefined, undefined, {
+				includeDataTableRows: false,
+			});
+
+			// Without the data_table SELECT id query, query count drops by 1 vs the
+			// includeDataTableRows=true path. Verify by ensuring no data_table query was
+			// issued and the schema-only log message was emitted.
+			const dataTableQueries = jest
+				.mocked(mockDataSource.query)
+				.mock.calls.filter(
+					([sql]) => typeof sql === 'string' && /SELECT id FROM "data_table"/.test(sql),
+				);
+			expect(dataTableQueries).toHaveLength(0);
+			expect(mockLogger.info).toHaveBeenCalledWith(
+				expect.stringContaining('Skipping data-table row export'),
+			);
+		});
+
 		it('should clear existing files before export', async () => {
 			const outputDir = '/test/output';
 			const existingFiles = ['user.jsonl', 'user.2.jsonl', 'other.txt'];
@@ -338,6 +370,103 @@ describe('ExportService', () => {
 		});
 	});
 
+	describe('exportDataTableUserTables', () => {
+		it('should silently skip when the data_table registry is missing', async () => {
+			jest.mocked(mockDataSource.query).mockImplementation(async (query: string) => {
+				if (query.includes('data_table') && !query.includes('data_table_column')) {
+					throw new Error('relation does not exist');
+				}
+				return [];
+			});
+
+			// @ts-expect-error accessing private method for testing
+			const result = await exportService.exportDataTableUserTables('/test/output');
+
+			expect(result).toEqual({ totalTables: 0, totalRows: 0 });
+		});
+
+		it('should skip when there are no data tables', async () => {
+			jest.mocked(mockDataSource.query).mockResolvedValueOnce([]); // SELECT id FROM data_table -> empty
+
+			// @ts-expect-error accessing private method for testing
+			const result = await exportService.exportDataTableUserTables('/test/output');
+
+			expect(result).toEqual({ totalTables: 0, totalRows: 0 });
+			expect(appendFile).not.toHaveBeenCalled();
+		});
+
+		it('should keyset-paginate user rows by id and write JSONL files', async () => {
+			const dataTableId = 'abc';
+
+			const firstPage = Array.from({ length: 500 }, (_, i) => ({
+				id: i + 1,
+				createdAt: '2024-01-01 00:00:00',
+				updatedAt: '2024-01-01 00:00:00',
+				val: i,
+			}));
+			const secondPage = [
+				{
+					id: 501,
+					createdAt: '2024-01-01 00:00:00',
+					updatedAt: '2024-01-01 00:00:00',
+					val: 500,
+				},
+			];
+
+			let queryCount = 0;
+			jest.mocked(mockDataSource.query).mockImplementation(async (query: string) => {
+				queryCount++;
+				if (query.includes('FROM') && query.includes('data_table_column')) {
+					return [{ dataTableId, name: 'val', type: 'number', index: 0 }];
+				}
+				if (query.startsWith('SELECT id FROM') && query.includes('data_table')) {
+					return [{ id: dataTableId }];
+				}
+				if (query.includes('data_table_user_')) {
+					if (query.includes('WHERE "id" > 0')) return firstPage;
+					if (query.includes('WHERE "id" > 500')) return secondPage;
+					return [];
+				}
+				return [];
+			});
+
+			jest.mocked(readdir).mockResolvedValue([]);
+
+			// @ts-expect-error accessing private method for testing
+			const result = await exportService.exportDataTableUserTables('/test/output');
+
+			expect(result.totalTables).toBe(1);
+			expect(result.totalRows).toBe(501);
+			// First file appended once for first page; second page rolls into a new file
+			expect(appendFile).toHaveBeenCalledTimes(2);
+			// 1 list-tables + 2 page queries — second page has < pageSize
+			// rows, so the loop short-circuits without a terminator query.
+			expect(queryCount).toBe(3);
+		});
+
+		it('should handle a missing dynamic table gracefully without aborting', async () => {
+			jest.mocked(mockDataSource.query).mockImplementation(async (query: string) => {
+				if (query.startsWith('SELECT id FROM') && query.includes('data_table')) {
+					return [{ id: 'broken' }];
+				}
+				if (query.includes('data_table_column')) return [];
+				if (query.includes('data_table_user_')) {
+					throw new Error('no such table');
+				}
+				return [];
+			});
+
+			// @ts-expect-error accessing private method for testing
+			const result = await exportService.exportDataTableUserTables('/test/output');
+
+			expect(result).toEqual({ totalTables: 1, totalRows: 0 });
+			expect(mockLogger.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Could not read rows'),
+				expect.objectContaining({ error: expect.any(Error) }),
+			);
+		});
+	});
+
 	describe('exportMigrationsTable', () => {
 		it('should export migrations table when it has data', async () => {
 			const outputDir = '/test/output';
diff --git a/packages/cli/src/services/__tests__/import.service.test.ts b/packages/cli/src/services/__tests__/import.service.test.ts
index 852758bb9fc..5c6a19f8acc 100644
--- a/packages/cli/src/services/__tests__/import.service.test.ts
+++ b/packages/cli/src/services/__tests__/import.service.test.ts
@@ -281,6 +281,7 @@ describe('ImportService', () => {
 					workflowentity: ['/test/input/workflowentity.jsonl'],
 				},
 				tableNames: ['user', 'workflow_entity'],
+				dataTableFiles: {},
 			});
 		});
 
@@ -301,6 +302,7 @@ describe('ImportService', () => {
 					user: ['/test/input/user.jsonl', '/test/input/user.2.jsonl', '/test/input/user.3.jsonl'],
 				},
 				tableNames: ['user'],
+				dataTableFiles: {},
 			});
 		});
 
@@ -314,6 +316,7 @@ describe('ImportService', () => {
 			expect(result).toEqual({
 				entityFiles: {},
 				tableNames: [],
+				dataTableFiles: {},
 			});
 		});
 
@@ -325,6 +328,7 @@ describe('ImportService', () => {
 			expect(result).toEqual({
 				entityFiles: {},
 				tableNames: [],
+				dataTableFiles: {},
 			});
 		});
 
@@ -338,6 +342,7 @@ describe('ImportService', () => {
 			expect(result).toEqual({
 				entityFiles: {},
 				tableNames: [],
+				dataTableFiles: {},
 			});
 		});
 
@@ -355,6 +360,37 @@ describe('ImportService', () => {
 					user: ['/test/input/user.jsonl'],
 				},
 				tableNames: ['user'],
+				dataTableFiles: {},
+			});
+		});
+
+		it('should route data-table user-row files into dataTableFiles', async () => {
+			const mockFiles = [
+				'user.jsonl',
+				'data_table_user_abc.jsonl',
+				'data_table_user_abc.2.jsonl',
+				'data_table_user_xyz.jsonl',
+			];
+
+			jest.mocked(readdir).mockResolvedValue(mockFiles as any);
+			jest
+				.mocked(safeJoinPath)
+				.mockReturnValueOnce('/test/input/user.jsonl')
+				.mockReturnValueOnce('/test/input/data_table_user_abc.jsonl')
+				.mockReturnValueOnce('/test/input/data_table_user_abc.2.jsonl')
+				.mockReturnValueOnce('/test/input/data_table_user_xyz.jsonl');
+
+			const result = await importService.getImportMetadata('/test/input');
+
+			expect(result).toEqual({
+				entityFiles: {
+					user: ['/test/input/user.jsonl'],
+				},
+				tableNames: ['user'],
+				dataTableFiles: {
+					abc: ['/test/input/data_table_user_abc.jsonl', '/test/input/data_table_user_abc.2.jsonl'],
+					xyz: ['/test/input/data_table_user_xyz.jsonl'],
+				},
 			});
 		});
 	});
@@ -1105,6 +1141,115 @@ describe('ImportService', () => {
 			expect(mockDataTableDDLService.createTableWithColumns).not.toHaveBeenCalled();
 			expect(mockDataTableDDLService.dropTable).not.toHaveBeenCalled();
 		});
+
+		describe('row import', () => {
+			beforeEach(() => {
+				mockDataSource.driver.escapeQueryWithParameters = jest
+					.fn()
+					.mockImplementation((sql, params) => [sql, params]);
+			});
+
+			it('should insert rows into the recreated backing table when files are provided', async () => {
+				mockEntityManager.query = jest
+					.fn()
+					.mockResolvedValueOnce([{ id: 'abc' }])
+					.mockResolvedValueOnce([
+						{ id: 'col-1', dataTableId: 'abc', name: 'flag', type: 'boolean', index: 0 },
+					])
+					.mockResolvedValue(undefined); // subsequent INSERTs
+
+				const row = {
+					id: 1,
+					createdAt: '2024-01-01 12:00:00',
+					updatedAt: '2024-01-01 12:00:00',
+					flag: 0,
+				};
+				jest.mocked(readFile).mockResolvedValue(JSON.stringify(row));
+
+				await importService.recreateDataTableUserTablesFromRegistry(mockEntityManager, {
+					abc: ['/test/input/data_table_user_abc.jsonl'],
+				});
+
+				const insertCalls = (mockEntityManager.query as jest.Mock).mock.calls.filter(
+					([sql]) => typeof sql === 'string' && sql.startsWith('INSERT INTO'),
+				);
+				expect(insertCalls).toHaveLength(1);
+				const [, params] = insertCalls[0];
+				// Boolean must have been normalised from 0 -> false (matters for cross-DB inserts)
+				expect((params as Record<string, unknown>).flag).toBe(false);
+				// id is preserved
+				expect((params as Record<string, unknown>).id).toBe(1);
+			});
+
+			it('should warn when archive has row files but registry is empty', async () => {
+				mockEntityManager.query = jest.fn().mockResolvedValueOnce([]);
+
+				await importService.recreateDataTableUserTablesFromRegistry(mockEntityManager, {
+					orphan: ['/test/input/data_table_user_orphan.jsonl'],
+				});
+
+				expect(mockLogger.warn).toHaveBeenCalledWith(
+					expect.stringContaining('but no entries in the data_table registry'),
+				);
+			});
+
+			it('should reset the id sequence after inserts on Postgres', async () => {
+				// @ts-expect-error overriding for the test
+				mockDataSource.options = { type: 'postgres' };
+
+				// Mixed-case id matters: pg_get_serial_sequence folds unquoted
+				// identifiers to lowercase, so the param must be the quoted form.
+				const mixedCaseId = 'AbC123';
+
+				mockEntityManager.query = jest
+					.fn()
+					.mockResolvedValueOnce([{ id: mixedCaseId }])
+					.mockResolvedValueOnce([
+						{ id: 'col-1', dataTableId: mixedCaseId, name: 'foo', type: 'string', index: 0 },
+					])
+					.mockResolvedValueOnce(undefined) // INSERT row
+					.mockResolvedValueOnce([{ column_name: 'id' }]) // information_schema lookup
+					.mockResolvedValue(undefined);
+
+				jest.mocked(readFile).mockResolvedValue(
+					JSON.stringify({
+						id: 5,
+						createdAt: '2024-01-01T00:00:00.000Z',
+						updatedAt: '2024-01-01T00:00:00.000Z',
+						foo: 'x',
+					}),
+				);
+
+				await importService.recreateDataTableUserTablesFromRegistry(mockEntityManager, {
+					[mixedCaseId]: [`/test/input/data_table_user_${mixedCaseId}.jsonl`],
+				});
+
+				const setvalCalls = (mockEntityManager.query as jest.Mock).mock.calls.filter(
+					([sql]) => typeof sql === 'string' && sql.includes('setval('),
+				);
+				expect(setvalCalls).toHaveLength(1);
+				const [, params] = setvalCalls[0];
+				expect(params).toEqual([`"data_table_user_${mixedCaseId}"`, 'id']);
+			});
+
+			it('should NOT call setval on Postgres when no rows were inserted', async () => {
+				// @ts-expect-error overriding for the test
+				mockDataSource.options = { type: 'postgres' };
+
+				mockEntityManager.query = jest
+					.fn()
+					.mockResolvedValueOnce([{ id: 'abc' }])
+					.mockResolvedValueOnce([])
+					.mockResolvedValue(undefined);
+
+				await importService.recreateDataTableUserTablesFromRegistry(mockEntityManager, {});
+
+				const setvalCalls = (mockEntityManager.query as jest.Mock).mock.calls.filter(
+					([sql]) => typeof sql === 'string' && sql.includes('setval('),
+				);
+				expect(setvalCalls).toHaveLength(0);
+			});
+		});
 	});
 
 	describe('advanceIdentitySequences', () => {
diff --git a/packages/cli/src/services/export.service.ts b/packages/cli/src/services/export.service.ts
index 99439add468..d9453835573 100644
--- a/packages/cli/src/services/export.service.ts
+++ b/packages/cli/src/services/export.service.ts
@@ -8,6 +8,9 @@ import { DataSource } from '@n8n/typeorm';
 import { validateDbTypeForExportEntities } from '@/utils/validate-database-type';
 import { Cipher } from 'n8n-core';
 import { compressFolder } from '@/utils/compression.util';
+import { quoteIdentifier, toTableName } from '@/modules/data-table/utils/sql-utils';
+
+const DATA_TABLE_ROWS_FILE_PREFIX = 'data_table_user_';
 
 @Service()
 export class ExportService {
@@ -90,11 +93,151 @@ export class ExportService {
 		return systemTablesExported;
 	}
 
+	private async loadDataTableIds(): Promise<string[]> {
+		const tablePrefix = this.dataSource.options.entityPrefix || '';
+		const dataTableTableName = `${tablePrefix}data_table`;
+
+		let dataTables: Array<{ id: string }>;
+		try {
+			dataTables = await this.dataSource.query(
+				`SELECT id FROM ${this.dataSource.driver.escape(dataTableTableName)}`,
+			);
+		} catch (error) {
+			this.logger.info(
+				`   ⚠️  ${dataTableTableName} registry not found, skipping data-table row export...`,
+				{ error },
+			);
+			return [];
+		}
+
+		if (dataTables.length === 0) {
+			this.logger.info('   ℹ️  No data tables found, nothing to export.');
+			return [];
+		}
+
+		return dataTables.map((t) => t.id);
+	}
+
+	private async exportSingleDataTable(
+		dataTableId: string,
+		outputDir: string,
+		customEncryptionKey: string | undefined,
+	): Promise<number> {
+		const dbType = this.dataSource.options.type;
+		const userTableName = toTableName(dataTableId);
+		const fileBaseName = `${DATA_TABLE_ROWS_FILE_PREFIX}${dataTableId}`;
+
+		this.logger.info(`\n📊 Processing data table: ${userTableName}`);
+
+		await this.clearExistingEntityFiles(outputDir, fileBaseName);
+
+		const idCol = quoteIdentifier('id', dbType);
+		const escapedUserTable = quoteIdentifier(userTableName, dbType);
+		const pageSize = 500;
+		const entitiesPerFile = 500;
+
+		let lastId = 0;
+		let fileIndex = 1;
+		let currentFileEntityCount = 0;
+		let totalEntityCount = 0;
+		let hasNextPage = true;
+
+		do {
+			let pageRows: Array<Record<string, unknown>>;
+			try {
+				pageRows = await this.dataSource.query(
+					`SELECT * FROM ${escapedUserTable} WHERE ${idCol} > ${lastId} ORDER BY "id" LIMIT ${pageSize}`,
+				);
+			} catch (error) {
+				this.logger.warn(
+					`   ⚠️  Could not read rows from ${userTableName}; skipping. The dynamic table may be missing on the source instance.`,
+					{ error },
+				);
+				break;
+			}
+
+			if (pageRows.length === 0) break;
+
+			const targetFileIndex = Math.floor(totalEntityCount / entitiesPerFile) + 1;
+			const fileName =
+				targetFileIndex === 1
+					? `${fileBaseName}.jsonl`
+					: `${fileBaseName}.${targetFileIndex}.jsonl`;
+			const filePath = safeJoinPath(outputDir, fileName);
+
+			if (targetFileIndex > fileIndex) {
+				this.logger.info(`   ✅ Completed file ${fileIndex}: ${currentFileEntityCount} rows`);
+				fileIndex = targetFileIndex;
+				currentFileEntityCount = 0;
+			}
+
+			const rowsJsonl = pageRows.map((row) => JSON.stringify(row)).join('\n');
+			await appendFile(
+				filePath,
+				(await this.cipher.encryptV2(rowsJsonl, customEncryptionKey)) + '\n',
+				'utf8',
+			);
+
+			const lastRowId = Number((pageRows[pageRows.length - 1] as { id: unknown }).id);
+			if (!Number.isFinite(lastRowId)) {
+				throw new Error(
+					`Unexpected non-numeric id in ${userTableName}; cannot continue keyset pagination`,
+				);
+			}
+			lastId = lastRowId;
+
+			totalEntityCount += pageRows.length;
+			currentFileEntityCount += pageRows.length;
+
+			this.logger.info(
+				`      Fetched ${pageRows.length} rows (last id: ${lastId}, total: ${totalEntityCount})`,
+			);
+
+			hasNextPage = pageRows.length >= pageSize;
+		} while (hasNextPage);
+
+		if (currentFileEntityCount > 0) {
+			this.logger.info(`   ✅ Completed file ${fileIndex}: ${currentFileEntityCount} rows`);
+		}
+
+		this.logger.info(
+			`   ✅ Completed export for ${userTableName}: ${totalEntityCount} rows in ${fileIndex} file(s)`,
+		);
+
+		return totalEntityCount;
+	}
+
+	private async exportDataTableUserTables(
+		outputDir: string,
+		customEncryptionKey?: string,
+	): Promise<{ totalTables: number; totalRows: number }> {
+		this.logger.info('\n📚 Exporting data table user rows:');
+		this.logger.info('==================================');
+
+		const dataTableIds = await this.loadDataTableIds();
+		if (dataTableIds.length === 0) {
+			return { totalTables: 0, totalRows: 0 };
+		}
+
+		let totalRows = 0;
+		for (const dataTableId of dataTableIds) {
+			totalRows += await this.exportSingleDataTable(dataTableId, outputDir, customEncryptionKey);
+		}
+
+		this.logger.info(
+			`\n📊 Data table row export summary: ${dataTableIds.length} table(s), ${totalRows} row(s)`,
+		);
+
+		return { totalTables: dataTableIds.length, totalRows };
+	}
+
 	async exportEntities(
 		outputDir: string,
 		excludedTables: Set<string> = new Set(),
 		keyFilePath?: string,
+		options: { includeDataTableRows?: boolean } = {},
 	) {
+		const { includeDataTableRows = true } = options;
 		this.logger.info('\n⚠️⚠️ This feature is currently under development. ⚠️⚠️');
 
 		validateDbTypeForExportEntities(this.dataSource.options.type);
@@ -133,6 +276,19 @@ export class ExportService {
 
 		await this.exportMigrationsTable(outputDir, customEncryptionKey);
 
+		if (includeDataTableRows) {
+			const dataTableRowsExported = await this.exportDataTableUserTables(
+				outputDir,
+				customEncryptionKey,
+			);
+			totalEntitiesExported += dataTableRowsExported.totalRows;
+			totalTablesProcessed += dataTableRowsExported.totalTables;
+		} else {
+			this.logger.info(
+				'\nℹ️  Skipping data-table row export (only schemas will be in the archive).',
+			);
+		}
+
 		for (const metadata of entityMetadatas) {
 			// Get table name and entity name
 			const tableName = metadata.tableName;
diff --git a/packages/cli/src/services/import.service.ts b/packages/cli/src/services/import.service.ts
index 379f60ca65b..83f79c73b59 100644
--- a/packages/cli/src/services/import.service.ts
+++ b/packages/cli/src/services/import.service.ts
@@ -33,7 +33,14 @@ import { ActiveWorkflowManager } from '@/active-workflow-manager';
 import type { IWorkflowWithVersionMetadata } from '@/interfaces';
 import { WorkflowIndexService } from '@/modules/workflow-index/workflow-index.service';
 import { DataTableDDLService } from '@/modules/data-table/data-table-ddl.service';
-import { DataTableColumn } from '@/modules/data-table/data-table-column.entity';
+import type { DataTableColumn } from '@/modules/data-table/data-table-column.entity';
+import {
+	normalizeUserRowValueForDatabase,
+	quoteIdentifier,
+	toTableName,
+} from '@/modules/data-table/utils/sql-utils';
+
+const DATA_TABLE_ROWS_FILE_PREFIX = 'data_table_user_';
 
 @Service()
 export class ImportService {
@@ -328,49 +335,64 @@ export class ImportService {
 	/**
 	 * Get import metadata including table names and entity files
 	 * @param inputDir - Directory containing exported entity files
-	 * @returns Object containing table names and entity files grouped by entity name
+	 * @returns Object containing table names, entity files grouped by entity name,
+	 *   and data-table row files grouped by data table id.
 	 */
 	async getImportMetadata(inputDir: string): Promise<{
 		tableNames: string[];
 		entityFiles: Record<string, string[]>;
+		dataTableFiles: Record<string, string[]>;
 	}> {
 		const files = await readdir(inputDir);
 		const entityTableNamesMap: Record<string, string> = {};
 		const entityFiles: Record<string, string[]> = {};
+		const dataTableFiles: Record<string, string[]> = {};
 
 		for (const file of files) {
-			if (file.endsWith('.jsonl')) {
-				const entityName = file.replace(/\.\d+\.jsonl$/, '.jsonl').replace('.jsonl', '');
-				// Exclude migrations from regular entity import
-				if (entityName === 'migrations') {
+			if (!file.endsWith('.jsonl')) continue;
+
+			const baseName = file.replace(/\.\d+\.jsonl$/, '.jsonl').replace('.jsonl', '');
+
+			// Exclude migrations from regular entity import
+			if (baseName === 'migrations') {
+				continue;
+			}
+
+			// Route data-table user-row files into their own bucket keyed by data table id.
+			if (baseName.startsWith(DATA_TABLE_ROWS_FILE_PREFIX)) {
+				const dataTableId = baseName.slice(DATA_TABLE_ROWS_FILE_PREFIX.length);
+				if (!dataTableFiles[dataTableId]) dataTableFiles[dataTableId] = [];
+				dataTableFiles[dataTableId].push(safeJoinPath(inputDir, file));
+				continue;
+			}
+
+			const entityName = baseName;
+
+			// Build table names map (only need to do this once per entity)
+			if (!entityTableNamesMap[entityName]) {
+				const entityMetadata = this.dataSource.entityMetadatas.find(
+					(meta) => meta.name.toLowerCase() === entityName,
+				);
+
+				if (!entityMetadata) {
+					this.logger.warn(`⚠️  No entity metadata found for ${entityName}, skipping...`);
 					continue;
 				}
 
-				// Build table names map (only need to do this once per entity)
-				if (!entityTableNamesMap[entityName]) {
-					const entityMetadata = this.dataSource.entityMetadatas.find(
-						(meta) => meta.name.toLowerCase() === entityName,
-					);
-
-					if (!entityMetadata) {
-						this.logger.warn(`⚠️  No entity metadata found for ${entityName}, skipping...`);
-						continue;
-					}
-
-					entityTableNamesMap[entityName] = entityMetadata.tableName;
-				}
-
-				// Build entity files map (only for entities with valid metadata)
-				if (!entityFiles[entityName]) {
-					entityFiles[entityName] = [];
-				}
-				entityFiles[entityName].push(safeJoinPath(inputDir, file));
+				entityTableNamesMap[entityName] = entityMetadata.tableName;
 			}
+
+			// Build entity files map (only for entities with valid metadata)
+			if (!entityFiles[entityName]) {
+				entityFiles[entityName] = [];
+			}
+			entityFiles[entityName].push(safeJoinPath(inputDir, file));
 		}
 
 		return {
 			tableNames: Object.values(entityTableNamesMap),
 			entityFiles,
+			dataTableFiles,
 		};
 	}
 
@@ -463,7 +485,7 @@ export class ImportService {
 
 			// Get import metadata after migration validation
 			const importMetadata = await this.getImportMetadata(inputDir);
-			const { tableNames, entityFiles } = importMetadata;
+			const { tableNames, entityFiles, dataTableFiles } = importMetadata;
 			const entityNames = Object.keys(entityFiles);
 
 			if (truncateTables) {
@@ -506,8 +528,12 @@ export class ImportService {
 			await this.advanceIdentitySequences(transactionManager, tableNames);
 
 			// After the data_table / data_table_column registry rows are imported,
-			// recreate the dynamic backing tables (empty) so the imported tables work.
-			await this.recreateDataTableUserTablesFromRegistry(transactionManager);
+			// recreate the dynamic backing tables and load any user rows from the archive.
+			await this.recreateDataTableUserTablesFromRegistry(
+				transactionManager,
+				dataTableFiles,
+				customEncryptionKey,
+			);
 
 			if (!skipTogglingForeignKeyConstraints) {
 				await this.enableForeignKeyConstraints(transactionManager);
@@ -710,15 +736,20 @@ export class ImportService {
 
 	/**
 	 * Recreate dynamic data-table backing tables for every entry in the imported
-	 * `data_table` registry. The export bug (ADO-5143) means archives produced
-	 * before this fix only contain registry rows; without recreating the backing
-	 * tables the imported data tables would reference tables that don't exist on
-	 * the destination.
+	 * `data_table` registry, and insert user rows from any matching JSONL files.
 	 *
 	 * Tables are dropped before recreation so the operation is idempotent and
-	 * handles stale tables left over from a partially-failed prior import.
+	 * handles stale tables left over from a partially-failed prior import. When
+	 * no row file exists for a table (e.g. an archive produced with
+	 * `--includeDataTableRows=false` or before this feature) the backing table
+	 * is recreated empty so the system stays functional.
 	 */
-	async recreateDataTableUserTablesFromRegistry(transactionManager: EntityManager): Promise<void> {
+	async recreateDataTableUserTablesFromRegistry(
+		transactionManager: EntityManager,
+		dataTableFiles: Record<string, string[]> = {},
+		customEncryptionKey?: string,
+	): Promise<void> {
+		const dbType = this.dataSource.options.type;
 		const tablePrefix = this.dataSource.options.entityPrefix || '';
 		const dataTableTableName = `${tablePrefix}data_table`;
 		const dataTableColumnTableName = `${tablePrefix}data_table_column`;
@@ -736,41 +767,92 @@ export class ImportService {
 			return;
 		}
 
-		if (dataTables.length === 0) return;
+		if (dataTables.length === 0) {
+			if (Object.keys(dataTableFiles).length > 0) {
+				this.logger.warn(
+					`   ⚠️  Found ${Object.keys(dataTableFiles).length} data-table row file(s) in the archive but no entries in the data_table registry; skipping.`,
+				);
+			}
+			return;
+		}
 
 		const escapedColumnTable = this.dataSource.driver.escape(dataTableColumnTableName);
 		const escapedDataTableId = this.dataSource.driver.escape('dataTableId');
 		const escapedIndex = this.dataSource.driver.escape('index');
 
-		const columnRows: Array<{
-			id: string;
-			dataTableId: string;
-			name: string;
-			type: 'string' | 'number' | 'boolean' | 'date';
-			index: number;
-		}> = await transactionManager.query(
+		const columnRows: DataTableColumn[] = await transactionManager.query(
 			`SELECT id, ${escapedDataTableId}, name, type, ${escapedIndex} FROM ${escapedColumnTable}`,
 		);
 
 		const columnsByDataTableId = new Map<string, DataTableColumn[]>();
 		for (const row of columnRows) {
 			const list = columnsByDataTableId.get(row.dataTableId) ?? [];
-			list.push(transactionManager.create(DataTableColumn, row));
+			list.push(row);
 			columnsByDataTableId.set(row.dataTableId, list);
 		}
 
 		this.logger.info(`\n📚 Recreating ${dataTables.length} data-table backing table(s)...`);
+		let totalRowsImported = 0;
 
 		for (const { id: dataTableId } of dataTables) {
+			const userTable = toTableName(dataTableId);
 			const cols = (columnsByDataTableId.get(dataTableId) ?? [])
 				.slice()
 				.sort((a, b) => a.index - b.index);
 
 			await this.dataTableDDLService.dropTable(dataTableId, transactionManager);
 			await this.dataTableDDLService.createTableWithColumns(dataTableId, cols, transactionManager);
+
+			const files = dataTableFiles[dataTableId];
+			if (!files || files.length === 0) continue;
+
+			const columnTypeMap = new Map<string, string>(cols.map((c) => [c.name, c.type]));
+			columnTypeMap.set('createdAt', 'date');
+			columnTypeMap.set('updatedAt', 'date');
+
+			const escapedTable = quoteIdentifier(userTable, dbType);
+			let rowsForTable = 0;
+
+			for (const filePath of files) {
+				const rows = await this.readEntityFile(filePath, customEncryptionKey);
+				for (const row of rows) {
+					const normalizedRow: Record<string, unknown> = {};
+					for (const [key, value] of Object.entries(row)) {
+						normalizedRow[key] = normalizeUserRowValueForDatabase(
+							value,
+							columnTypeMap.get(key),
+							dbType,
+						);
+					}
+
+					const columnNames = Object.keys(normalizedRow);
+					const escapedCols = columnNames.map((c) => quoteIdentifier(c, dbType)).join(', ');
+					const placeholders = columnNames.map((c) => `:${c}`).join(', ');
+					const [query, params] = this.dataSource.driver.escapeQueryWithParameters(
+						`INSERT INTO ${escapedTable} (${escapedCols}) VALUES (${placeholders})`,
+						normalizedRow,
+						{},
+					);
+					await transactionManager.query(query, params);
+					rowsForTable++;
+				}
+			}
+
+			// Postgres IDENTITY columns don't auto-advance when explicit ids are
+			// inserted, so the next implicit insert would collide. Reset to MAX(id).
+			if (rowsForTable > 0 && dbType === 'postgres') {
+				await this.advanceIdentitySequences(transactionManager, [userTable]);
+			}
+
+			if (rowsForTable > 0) {
+				this.logger.info(`   ✅ ${userTable}: ${rowsForTable} row(s) imported`);
+			}
+			totalRowsImported += rowsForTable;
 		}
 
-		this.logger.info(`✅ Recreated ${dataTables.length} data-table backing table(s)`);
+		this.logger.info(
+			`✅ Recreated ${dataTables.length} data-table backing table(s); imported ${totalRowsImported} row(s)`,
+		);
 	}
 
 	/**
diff --git a/packages/cli/src/task-runners/__tests__/task-runner-process-py.test.ts b/packages/cli/src/task-runners/__tests__/task-runner-process-py.test.ts
new file mode 100644
index 00000000000..a15bf677be6
--- /dev/null
+++ b/packages/cli/src/task-runners/__tests__/task-runner-process-py.test.ts
@@ -0,0 +1,82 @@
+import { Logger } from '@n8n/backend-common';
+import { mockInstance } from '@n8n/backend-test-utils';
+import { TaskRunnersConfig } from '@n8n/config';
+import { mock } from 'jest-mock-extended';
+import type { ChildProcess, SpawnOptions } from 'node:child_process';
+
+import type { TaskBrokerAuthService } from '@/task-runners/task-broker/auth/task-broker-auth.service';
+import { PyTaskRunnerProcess } from '@/task-runners/task-runner-process-py';
+
+const spawnMock = jest.fn(() =>
+	mock<ChildProcess>({
+		stdout: {
+			pipe: jest.fn(),
+		},
+		stderr: {
+			pipe: jest.fn(),
+		},
+	}),
+);
+require('child_process').spawn = spawnMock;
+
+describe('PyTaskRunnerProcess', () => {
+	const logger = mockInstance(Logger);
+	const runnerConfig = mockInstance(TaskRunnersConfig);
+	runnerConfig.mode = 'internal';
+	const authService = mock<TaskBrokerAuthService>();
+	let taskRunnerProcess = new PyTaskRunnerProcess(logger, runnerConfig, authService, mock());
+
+	afterEach(() => {
+		spawnMock.mockClear();
+	});
+
+	describe('start', () => {
+		beforeEach(() => {
+			taskRunnerProcess = new PyTaskRunnerProcess(logger, runnerConfig, authService, mock());
+			jest.spyOn(authService, 'createGrantToken').mockResolvedValue('grantToken');
+		});
+
+		test.each([
+			'PATH',
+			'N8N_RUNNERS_STDLIB_ALLOW',
+			'N8N_RUNNERS_EXTERNAL_ALLOW',
+			'N8N_RUNNERS_BUILTINS_DENY',
+			'N8N_BLOCK_RUNNER_ENV_ACCESS',
+		])('should propagate %s from env as is', async (envVar) => {
+			process.env[envVar] = 'custom value';
+
+			await taskRunnerProcess.start();
+
+			// @ts-expect-error The type is not correct
+			const options = spawnMock.mock.calls[0][2] as SpawnOptions;
+			expect(options.env).toEqual(
+				expect.objectContaining({
+					[envVar]: 'custom value',
+				}),
+			);
+		});
+
+		it('should build env with a null prototype', async () => {
+			await taskRunnerProcess.start();
+
+			// @ts-expect-error The type is not correct
+			const options = spawnMock.mock.calls[0][2] as SpawnOptions;
+			expect(Object.getPrototypeOf(options.env)).toBeNull();
+		});
+
+		it('should not inherit env keys from Object.prototype', async () => {
+			const proto = Object.prototype as Record<string, unknown>;
+			proto.NODE_OPTIONS = '--inherited-value';
+
+			try {
+				await taskRunnerProcess.start();
+
+				// @ts-expect-error The type is not correct
+				const options = spawnMock.mock.calls[0][2] as SpawnOptions;
+				expect(options.env?.NODE_OPTIONS).toBeUndefined();
+			} finally {
+				delete proto.NODE_OPTIONS;
+			}
+		});
+	});
+});
diff --git a/packages/cli/src/task-runners/__tests__/task-runner-process.test.ts b/packages/cli/src/task-runners/__tests__/task-runner-process.test.ts
index c6011198b55..c409b10f9c0 100644
--- a/packages/cli/src/task-runners/__tests__/task-runner-process.test.ts
+++ b/packages/cli/src/task-runners/__tests__/task-runner-process.test.ts
@@ -120,6 +120,33 @@ describe('TaskRunnerProcess', () => {
 			expect(options.env).not.toHaveProperty('NODE_OPTIONS');
 		});
 
+		it('should build env with a null prototype', async () => {
+			jest.spyOn(authService, 'createGrantToken').mockResolvedValue('grantToken');
+
+			await taskRunnerProcess.start();
+
+			// @ts-expect-error The type is not correct
+			const options = spawnMock.mock.calls[0][2] as SpawnOptions;
+			expect(Object.getPrototypeOf(options.env)).toBeNull();
+		});
+
+		it('should not inherit env keys from Object.prototype', async () => {
+			jest.spyOn(authService, 'createGrantToken').mockResolvedValue('grantToken');
+			runnerConfig.maxOldSpaceSize = '';
+			const proto = Object.prototype as Record<string, unknown>;
+			proto.NODE_OPTIONS = '--inherited-value';
+
+			try {
+				await taskRunnerProcess.start();
+
+				// @ts-expect-error The type is not correct
+				const options = spawnMock.mock.calls[0][2] as SpawnOptions;
+				expect(options.env?.NODE_OPTIONS).toBeUndefined();
+			} finally {
+				delete proto.NODE_OPTIONS;
+			}
+		});
+
 		it('should pass N8N_RUNNERS_TASK_TIMEOUT if set', async () => {
 			jest.spyOn(authService, 'createGrantToken').mockResolvedValue('grantToken');
 			runnerConfig.taskTimeout = 123;
diff --git a/packages/cli/src/task-runners/task-runner-process-js.ts b/packages/cli/src/task-runners/task-runner-process-js.ts
index 54b7181074a..69e1e145654 100644
--- a/packages/cli/src/task-runners/task-runner-process-js.ts
+++ b/packages/cli/src/task-runners/task-runner-process-js.ts
@@ -53,7 +53,7 @@ export class JsTaskRunnerProcess extends TaskRunnerProcessBase {
 	}
 
 	private getProcessEnvVars(grantToken: string, taskBrokerUri: string) {
-		const envVars: Record<string, string | undefined> = {
+		const envVars: Record<string, string | undefined> = Object.assign(Object.create(null), {
 			// system environment
 			PATH: process.env.PATH,
 			HOME: process.env.HOME ?? process.env.USERPROFILE,
@@ -78,7 +78,7 @@ export class JsTaskRunnerProcess extends TaskRunnerProcessBase {
 			N8N_RUNNERS_TASK_TIMEOUT: this.runnerConfig.taskTimeout.toString(),
 			N8N_RUNNERS_HEARTBEAT_INTERVAL: this.runnerConfig.heartbeatInterval.toString(),
 			N8N_RUNNERS_INSECURE_MODE: process.env.N8N_RUNNERS_INSECURE_MODE,
-		};
+		});
 
 		if (this.runnerConfig.maxOldSpaceSize) {
 			envVars.NODE_OPTIONS = `--max-old-space-size=${this.runnerConfig.maxOldSpaceSize}`;
diff --git a/packages/cli/src/task-runners/task-runner-process-py.ts b/packages/cli/src/task-runners/task-runner-process-py.ts
index a60c636d02e..ab02c9edbc7 100644
--- a/packages/cli/src/task-runners/task-runner-process-py.ts
+++ b/packages/cli/src/task-runners/task-runner-process-py.ts
@@ -37,7 +37,7 @@ export class PyTaskRunnerProcess extends TaskRunnerProcessBase {
 
 		return spawn(venvPath, ['-m', 'src.main'], {
 			cwd: pythonDir,
-			env: {
+			env: Object.assign(Object.create(null), {
 				// system environment
 				PATH: process.env.PATH,
 				HOME: process.env.HOME ?? process.env.USERPROFILE,
@@ -55,7 +55,7 @@ export class PyTaskRunnerProcess extends TaskRunnerProcessBase {
 				N8N_RUNNERS_EXTERNAL_ALLOW: process.env.N8N_RUNNERS_EXTERNAL_ALLOW,
 				N8N_RUNNERS_BUILTINS_DENY: process.env.N8N_RUNNERS_BUILTINS_DENY,
 				N8N_BLOCK_RUNNER_ENV_ACCESS: process.env.N8N_BLOCK_RUNNER_ENV_ACCESS,
-			},
+			}),
 		});
 	}
 
diff --git a/packages/cli/test/integration/controllers/oauth/oauth1.api.test.ts b/packages/cli/test/integration/controllers/oauth/oauth1.api.test.ts
new file mode 100644
index 00000000000..2366acfbafc
--- /dev/null
+++ b/packages/cli/test/integration/controllers/oauth/oauth1.api.test.ts
@@ -0,0 +1,187 @@
+import { createTeamProject, linkUserToProject, testDb } from '@n8n/backend-test-utils';
+import type { CredentialsEntity, User } from '@n8n/db';
+import { Container } from '@n8n/di';
+import { response as Response } from 'express';
+import nock from 'nock';
+
+import { CredentialsHelper } from '@/credentials-helper';
+import { OauthService } from '@/oauth/oauth.service';
+import {
+	decryptCredentialData,
+	getCredentialById,
+	saveCredential,
+	shareCredentialWithUsers,
+} from '@test-integration/db/credentials';
+import { createMember, createOwner } from '@test-integration/db/users';
+import { setupTestServer } from '@test-integration/utils';
+
+describe('OAuth1 API', () => {
+	const testServer = setupTestServer({ endpointGroups: ['oauth1'] });
+
+	let owner: User;
+	let credential: CredentialsEntity;
+	const credentialData = {
+		consumerKey: 'consumer_key',
+		consumerSecret: 'consumer_secret',
+		authUrl: 'https://test.domain/oauth1/auth',
+		requestTokenUrl: 'https://test.domain/oauth1/request_token',
+		accessTokenUrl: 'https://test.domain/oauth1/access_token',
+		signatureMethod: 'HMAC-SHA1' as const,
+	};
+
+	const sharedCredentialPayload = {
+		name: 'Shared OAuth1 credential',
+		type: 'testOAuth1Api',
+		data: credentialData,
+	};
+
+	CredentialsHelper.prototype.applyDefaultsAndOverwrites = async (_, decryptedDataOriginal) =>
+		decryptedDataOriginal;
+
+	beforeAll(async () => {
+		owner = await createOwner();
+	});
+
+	beforeEach(async () => {
+		await testDb.truncate(['SharedCredentials', 'CredentialsEntity']);
+		credential = await saveCredential(sharedCredentialPayload, {
+			user: owner,
+			role: 'credential:owner',
+		});
+	});
+
+	afterEach(() => {
+		jest.restoreAllMocks();
+		nock.cleanAll();
+	});
+
+	describe('OAuth reconnect authorization', () => {
+		const expectNoCsrfStateOnCredential = async (credentialId: string) => {
+			const stored = await getCredentialById(credentialId);
+			expect(stored).not.toBeNull();
+			const decrypted = (await decryptCredentialData(stored!)) as Record<string, unknown>;
+			expect(decrypted).not.toHaveProperty('csrfSecret');
+		};
+
+		const mockRequestTokenEndpoint = () => {
+			nock('https://test.domain')
+				.post('/oauth1/request_token')
+				.reply(200, 'oauth_token=request_token&oauth_token_secret=request_secret');
+		};
+
+		it('should reject auth start for a sharee with credential:user role', async () => {
+			const sharee = await createMember();
+			await shareCredentialWithUsers(credential, [sharee]);
+
+			const response = await testServer
+				.authAgentFor(sharee)
+				.get('/oauth1-credential/auth')
+				.query({ id: credential.id });
+
+			expect(response.statusCode).toBe(404);
+			await expectNoCsrfStateOnCredential(credential.id);
+		});
+
+		it('should reject auth start for a project viewer on a project-shared credential', async () => {
+			const projectViewer = await createMember();
+			const teamProject = await createTeamProject(undefined, owner);
+			await linkUserToProject(projectViewer, teamProject, 'project:viewer');
+
+			const projectCredential = await saveCredential(sharedCredentialPayload, {
+				project: teamProject,
+				role: 'credential:owner',
+			});
+
+			const response = await testServer
+				.authAgentFor(projectViewer)
+				.get('/oauth1-credential/auth')
+				.query({ id: projectCredential.id });
+
+			expect(response.statusCode).toBe(404);
+			await expectNoCsrfStateOnCredential(projectCredential.id);
+		});
+
+		it('should allow auth start for a project editor on a project-shared credential', async () => {
+			const projectEditor = await createMember();
+			const teamProject = await createTeamProject(undefined, owner);
+			await linkUserToProject(projectEditor, teamProject, 'project:editor');
+
+			const projectCredential = await saveCredential(sharedCredentialPayload, {
+				project: teamProject,
+				role: 'credential:owner',
+			});
+
+			mockRequestTokenEndpoint();
+
+			const response = await testServer
+				.authAgentFor(projectEditor)
+				.get('/oauth1-credential/auth')
+				.query({ id: projectCredential.id });
+
+			expect(response.statusCode).toBe(200);
+			expect(response.body.data).toContain('https://test.domain/oauth1/auth');
+			expect(response.body.data).toContain('oauth_token=request_token');
+		});
+
+		it('should reject callback when requester lacks credential:update on the target credential', async () => {
+			const sharee = await createMember();
+			await shareCredentialWithUsers(credential, [sharee]);
+
+			const oauthService = Container.get(OauthService);
+			const renderSpy = jest.spyOn(Response, 'render').mockImplementation(function (this: any) {
+				this.end();
+				return this;
+			});
+
+			// Build a callback state whose decrypted userId equals the requesting member,
+			// so the userId equality check inside decodeCsrfState passes and the credential
+			// scope check is the only remaining gate. The owner-initiated /auth call below
+			// produces a valid encrypted state; we then re-encrypt its contents with the
+			// member's userId before driving the callback as the member.
+			const csrfSpy = jest.spyOn(oauthService, 'createCsrfState').mockClear();
+			mockRequestTokenEndpoint();
+
+			await testServer
+				.authAgentFor(owner)
+				.get('/oauth1-credential/auth')
+				.query({ id: credential.id })
+				.expect(200);
+
+			const [, ownerState] = await csrfSpy.mock.results[0].value;
+
+			const decoded = JSON.parse(Buffer.from(ownerState, 'base64').toString());
+			const decryptedData = JSON.parse(oauthService['cipher'].decrypt(decoded.data)) as Record<
+				string,
+				unknown
+			>;
+			decryptedData.userId = sharee.id;
+			decoded.data = oauthService['cipher'].encrypt(JSON.stringify(decryptedData));
+			const reencodedState = Buffer.from(JSON.stringify(decoded)).toString('base64');
+
+			nock('https://test.domain')
+				.post('/oauth1/access_token')
+				.reply(200, 'oauth_token=member_token&oauth_token_secret=member_secret');
+
+			await testServer
+				.authAgentFor(sharee)
+				.get('/oauth1-credential/callback')
+				.query({
+					oauth_token: 'request_token',
+					oauth_verifier: 'verifier',
+					state: reencodedState,
+				})
+				.expect(200);
+
+			expect(renderSpy).toHaveBeenCalledWith('oauth-error-callback', {
+				error: { message: 'Credential not found' },
+			});
+
+			const stored = await Container.get(CredentialsHelper).getCredentials(
+				credential,
+				credential.type,
+			);
+			const credentials = await stored.getData();
+			expect(credentials.oauthTokenData).toBeUndefined();
+		});
+	});
+});
diff --git a/packages/cli/test/integration/controllers/oauth/oauth2.api.test.ts b/packages/cli/test/integration/controllers/oauth/oauth2.api.test.ts
index ef4642e17dc..083b07dd9ee 100644
--- a/packages/cli/test/integration/controllers/oauth/oauth2.api.test.ts
+++ b/packages/cli/test/integration/controllers/oauth/oauth2.api.test.ts
@@ -1,4 +1,4 @@
-import { testDb } from '@n8n/backend-test-utils';
+import { createTeamProject, linkUserToProject, testDb } from '@n8n/backend-test-utils';
 import type { CredentialsEntity, User } from '@n8n/db';
 import { Container } from '@n8n/di';
 import { response as Response } from 'express';
@@ -8,7 +8,12 @@ import { parse as parseQs } from 'querystring';
 import { CredentialsHelper } from '@/credentials-helper';
 import { ExternalHooks } from '@/external-hooks';
 import { OauthService } from '@/oauth/oauth.service';
-import { saveCredential } from '@test-integration/db/credentials';
+import {
+	decryptCredentialData,
+	getCredentialById,
+	saveCredential,
+	shareCredentialWithUsers,
+} from '@test-integration/db/credentials';
 import { createMember, createOwner } from '@test-integration/db/users';
 import type { SuperAgentTest } from '@test-integration/types';
 import { setupTestServer } from '@test-integration/utils';
@@ -52,6 +57,10 @@ describe('OAuth2 API', () => {
 		);
 	});
 
+	afterEach(() => {
+		jest.restoreAllMocks();
+	});
+
 	it('should return a valid auth URL when the auth flow is initiated', async () => {
 		const response = await ownerAgent
 			.get('/oauth2-credential/auth')
@@ -131,9 +140,10 @@ describe('OAuth2 API', () => {
 	it('should fail on auth when callback is called as another user', async () => {
 		const oauthService = Container.get(OauthService);
 		const csrfSpy = jest.spyOn(oauthService, 'createCsrfState').mockClear();
-		const renderSpy = (Response.render = jest.fn(function () {
+		const renderSpy = jest.spyOn(Response, 'render').mockImplementation(function (this: any) {
 			this.end();
-		}));
+			return this;
+		});
 
 		await ownerAgent.get('/oauth2-credential/auth').query({ id: credential.id }).expect(200);
 
@@ -153,9 +163,10 @@ describe('OAuth2 API', () => {
 	it('should handle a valid callback without auth', async () => {
 		const oauthService = Container.get(OauthService);
 		const csrfSpy = jest.spyOn(oauthService, 'createCsrfState').mockClear();
-		const renderSpy = (Response.render = jest.fn(function () {
+		const renderSpy = jest.spyOn(Response, 'render').mockImplementation(function (this: any) {
 			this.end();
-		}));
+			return this;
+		});
 
 		await ownerAgent.get('/oauth2-credential/auth').query({ id: credential.id }).expect(200);
 
@@ -179,4 +190,124 @@ describe('OAuth2 API', () => {
 			oauthTokenData: { access_token: 'updated_token' },
 		});
 	});
+
+	describe('OAuth reconnect authorization', () => {
+		const sharedCredentialPayload = {
+			name: 'Shared OAuth2 credential',
+			type: 'testOAuth2Api',
+			data: credentialData,
+		};
+
+		const expectNoCsrfStateOnCredential = async (credentialId: string) => {
+			const stored = await getCredentialById(credentialId);
+			expect(stored).not.toBeNull();
+			const decrypted = (await decryptCredentialData(stored!)) as Record<string, unknown>;
+			expect(decrypted).not.toHaveProperty('csrfSecret');
+			expect(decrypted).not.toHaveProperty('codeVerifier');
+		};
+
+		it('should reject auth start for a sharee with credential:user role', async () => {
+			const sharee = await createMember();
+			await shareCredentialWithUsers(credential, [sharee]);
+
+			const response = await testServer
+				.authAgentFor(sharee)
+				.get('/oauth2-credential/auth')
+				.query({ id: credential.id });
+
+			expect(response.statusCode).toBe(404);
+			await expectNoCsrfStateOnCredential(credential.id);
+		});
+
+		it('should reject auth start for a project viewer on a project-shared credential', async () => {
+			const projectViewer = await createMember();
+			const teamProject = await createTeamProject(undefined, owner);
+			await linkUserToProject(projectViewer, teamProject, 'project:viewer');
+
+			const projectCredential = await saveCredential(sharedCredentialPayload, {
+				project: teamProject,
+				role: 'credential:owner',
+			});
+
+			const response = await testServer
+				.authAgentFor(projectViewer)
+				.get('/oauth2-credential/auth')
+				.query({ id: projectCredential.id });
+
+			expect(response.statusCode).toBe(404);
+			await expectNoCsrfStateOnCredential(projectCredential.id);
+		});
+
+		it('should allow auth start for a project editor on a project-shared credential', async () => {
+			const projectEditor = await createMember();
+			const teamProject = await createTeamProject(undefined, owner);
+			await linkUserToProject(projectEditor, teamProject, 'project:editor');
+
+			const projectCredential = await saveCredential(sharedCredentialPayload, {
+				project: teamProject,
+				role: 'credential:owner',
+			});
+
+			const response = await testServer
+				.authAgentFor(projectEditor)
+				.get('/oauth2-credential/auth')
+				.query({ id: projectCredential.id });
+
+			expect(response.statusCode).toBe(200);
+			expect(response.body.data).toContain('https://test.domain/oauth2/auth');
+		});
+
+		it('should reject callback when requester lacks credential:update on the target credential', async () => {
+			const sharee = await createMember();
+			await shareCredentialWithUsers(credential, [sharee]);
+
+			const oauthService = Container.get(OauthService);
+			const renderSpy = (Response.render = jest.fn(function () {
+				this.end();
+			}));
+
+			// Build a callback state whose decrypted userId equals the requesting member,
+			// so the userId equality check inside decodeCsrfState passes and the credential
+			// scope check is the only remaining gate. The owner-initiated /auth call below
+			// produces a valid encrypted state; we then re-encrypt its contents with the
+			// member's userId before driving the callback as the member.
+			const ownerAgentForSetup = testServer.authAgentFor(owner);
+			const csrfSpy = jest.spyOn(oauthService, 'createCsrfState').mockClear();
+			await ownerAgentForSetup
+				.get('/oauth2-credential/auth')
+				.query({ id: credential.id })
+				.expect(200);
+			const [, ownerState] = await csrfSpy.mock.results[0].value;
+
+			const decoded = JSON.parse(Buffer.from(ownerState, 'base64').toString());
+			const decryptedData = JSON.parse(oauthService['cipher'].decrypt(decoded.data)) as Record<
+				string,
+				unknown
+			>;
+			decryptedData.userId = sharee.id;
+			decoded.data = oauthService['cipher'].encrypt(JSON.stringify(decryptedData));
+			const reencodedState = Buffer.from(JSON.stringify(decoded)).toString('base64');
+
+			nock('https://test.domain')
+				.post('/oauth2/token')
+				.reply(200, { access_token: 'member_token' });
+
+			await testServer
+				.authAgentFor(sharee)
+				.get('/oauth2-credential/callback')
+				.query({ code: 'auth_code', state: reencodedState })
+				.expect(200);
+
+			expect(renderSpy).toHaveBeenCalledWith('oauth-error-callback', {
+				error: { message: 'Credential not found' },
+			});
+
+			const updatedCredential = await Container.get(CredentialsHelper).getCredentials(
+				credential,
+				credential.type,
+			);
+			const credentials = await updatedCredential.getData();
+			expect(credentials.oauthTokenData).toBeUndefined();
+		});
+	});
 });
diff --git a/packages/cli/test/integration/shared/types.ts b/packages/cli/test/integration/shared/types.ts
index 6976ac7efe2..0250784d115 100644
--- a/packages/cli/test/integration/shared/types.ts
+++ b/packages/cli/test/integration/shared/types.ts
@@ -12,6 +12,7 @@ type EndpointGroup =
 	| 'me'
 	| 'users'
 	| 'auth'
+	| 'oauth1'
 	| 'oauth2'
 	| 'owner'
 	| 'passwordReset'
diff --git a/packages/cli/test/integration/shared/utils/test-server.ts b/packages/cli/test/integration/shared/utils/test-server.ts
index 54083cf9f17..e026f752457 100644
--- a/packages/cli/test/integration/shared/utils/test-server.ts
+++ b/packages/cli/test/integration/shared/utils/test-server.ts
@@ -223,6 +223,10 @@ export const setupTestServer = ({
 						await import('@/controllers/auth.controller');
 						break;
 
+					case 'oauth1':
+						await import('@/controllers/oauth/oauth1-credential.controller');
+						break;
+
 					case 'oauth2':
 						await import('@/controllers/oauth/oauth2-credential.controller');
 						break;
diff --git a/packages/core/src/execution-engine/__tests__/workflow-execute.test.ts b/packages/core/src/execution-engine/__tests__/workflow-execute.test.ts
index 6b1ddd5f314..d11a5d3fbfb 100644
--- a/packages/core/src/execution-engine/__tests__/workflow-execute.test.ts
+++ b/packages/core/src/execution-engine/__tests__/workflow-execute.test.ts
@@ -80,6 +80,36 @@ describe('WorkflowExecute', () => {
 			.mockImplementation(() => {});
 	});
 
+	describe('retryOnFail', () => {
+		it('should not trigger retry when error field is null', async () => {
+			const retryNode: INode = {
+				...createNodeData({ name: 'retryNode' }),
+				retryOnFail: true,
+				maxTries: 3,
+				waitBetweenTries: 1,
+			};
+			const workflow = new Workflow({
+				id: 'test',
+				nodes: [retryNode],
+				connections: {},
+				active: false,
+				nodeTypes,
+			});
+			const waitPromise = createDeferredPromise<IRun>();
+			const additionalData = Helpers.WorkflowExecuteAdditionalData(waitPromise);
+			const workflowExecute = new WorkflowExecute(additionalData, 'manual');
+			const runNodeSpy = jest.spyOn(workflowExecute, 'runNode').mockResolvedValue({
+				data: [[{ json: { error: null } }]],
+			});
+
+			await workflowExecute.run({ workflow, startNode: retryNode });
+			const result = await waitPromise.promise;
+
+			expect(result.finished).toBe(true);
+			expect(runNodeSpy).toHaveBeenCalledTimes(1);
+		});
+	});
+
 	describe('v0 execution order', () => {
 		const tests: WorkflowTestData[] = legacyWorkflowExecuteTests;
 
diff --git a/packages/core/src/execution-engine/workflow-execute.ts b/packages/core/src/execution-engine/workflow-execute.ts
index 236f052ac60..a7e44cb1885 100644
--- a/packages/core/src/execution-engine/workflow-execute.ts
+++ b/packages/core/src/execution-engine/workflow-execute.ts
@@ -1626,6 +1626,9 @@ export class WorkflowExecute {
 						await hooks.runHook('nodeExecuteBefore', [executionNode.name, taskStartedData]);
 					}
 					let maxTries = 1;
+					const isErrorValue = (v: unknown) => v !== undefined && v !== null && v !== false;
+					const checkFailure = (data: IRunNodeResponse | EngineRequest) =>
+						!isEngineRequest(data) && isErrorValue(data.data?.[0]?.[0]?.json?.error);
 					if (executionData.node.retryOnFail === true) {
 						// TODO: Remove the hardcoded default-values here and also in NodeSettings.vue
 						maxTries = Math.min(5, Math.max(2, executionData.node.maxTries || 3));
@@ -1695,9 +1698,7 @@ export class WorkflowExecute {
 									subNodeExecutionResults,
 								);
 
-								let nodeFailed =
-									!isEngineRequest(runNodeData) &&
-									runNodeData.data?.[0]?.[0]?.json?.error !== undefined;
+								let nodeFailed = checkFailure(runNodeData);
 
 								while (nodeFailed && tryIndex !== maxTries - 1) {
 									await sleep(waitBetweenTries);
@@ -1712,9 +1713,7 @@ export class WorkflowExecute {
 										this.abortController.signal,
 									);
 
-									nodeFailed =
-										!isEngineRequest(runNodeData) &&
-										runNodeData.data?.[0]?.[0]?.json?.error !== undefined;
+									nodeFailed = checkFailure(runNodeData);
 									tryIndex++;
 								}
 
diff --git a/packages/frontend/@n8n/i18n/src/locales/en.json b/packages/frontend/@n8n/i18n/src/locales/en.json
index 64269b21392..7fdc90b0c2a 100644
--- a/packages/frontend/@n8n/i18n/src/locales/en.json
+++ b/packages/frontend/@n8n/i18n/src/locales/en.json
@@ -2938,6 +2938,44 @@
 	"settings.mcp.connectPopover.serverUrl": "Server URL",
 	"settings.mcp.connectPopover.jsonConfig": "Configuration JSON",
 	"settings.mcp.connectPopover.triggerLabel": "Connection details",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.title": "Build from your assistant",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.description": "Connect MCP clients like Claude Code and Cursor to build, run, and iterate on workflows in your instance",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.client.claude": "Claude",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.client.claudeCode": "Claude Code",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.client.cursor": "Cursor",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.client.codex": "Codex",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.client.chatgpt": "ChatGPT",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.eyebrow": "New · Model Context Protocol",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.title": "Try MCP with Claude Code, Cursor, or Codex",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.description": "Connect MCP clients like Claude Code and Cursor to build, run, and iterate on workflows in your instance.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.settingsHint": "Set it up now, or later in {settingsLink}.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.settingsLink": "Settings > Instance-level MCP",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.tryIt": "Try MCP",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.intro.skip": "Skip for now",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.claude": "Show me the n8n MCP connector and walk me through enabling it if it isn't already on. I'll paste my server URL when you tell me where it goes.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.claudeCode": "Set up the n8n MCP server for Claude Code so it's available across all projects.\n\n1. Register the server at user scope by running:\n\n   claude mcp add --scope user --transport http n8n \"{serverUrl}\"\n\n2. Once it's registered, remind me to restart Claude Code — I'll complete the n8n OAuth flow when prompted in the new session, so don't try to list or call its tools yet.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.cursor": "Set up the n8n MCP server for Cursor across all projects.\n\n1. Open ~/.cursor/mcp.json (create the file and directory if they don't exist). Add the entry below, merging with any existing config so other servers stay intact:\n\n   {'{'}\n     \"mcpServers\": {'{'}\n       \"n8n\": {'{'}\n         \"url\": \"{serverUrl}\"\n       {'}'}\n     {'}'}\n   {'}'}\n\n2. Once it's saved, remind me to restart Cursor and complete the n8n OAuth flow when it prompts me — the server's tools won't be available until then.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.codex": "Set up the n8n MCP server for Codex across all projects.\n\n1. Open ~/.codex/config.toml (create the file and directory if they don't exist). Append the section below, leaving any existing config in place:\n\n   [mcp_servers.n8n]\n   url = \"{serverUrl}\"\n\n2. Once it's saved, remind me to restart Codex and complete the n8n OAuth flow in my browser when it prompts me — the server's tools won't be available until then.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.client.title": "Choose your assistant",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.access.title": "Enable MCP access",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.prompt.title": "Paste the prompt in {assistant}",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.serverUrl.title": "Paste Server URL",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.restart.title": "Restart {assistant} and connect to n8n",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptDeveloperMode.title": "Enable developer mode in ChatGPT",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptDeveloperMode.description": "In ChatGPT, go to Settings > Apps & Connectors > Advanced settings. Turn on developer mode.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.title": "Create a custom app",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.appName.label": "App name",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.appName.value": "n8n",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.serverUrl.label": "Server URL",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.footer": "You can disable this later from {settingsLink}. Read more about this feature {docsLink}.",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.footer.docsLink": "here",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.copy.tooltip": "Copy setup prompt",
+	"experiments.surfaceMcpToNewCloudUsers.onboarding.copy.copied": "Copied",
+	"experiments.surfaceMcpToNewCloudUsers.emptyState.tile.variant1.cta": "Build from your assistant",
+	"experiments.surfaceMcpToNewCloudUsers.emptyState.tile.variant2.cta": "Connect to your AI",
+	"experiments.surfaceMcpToNewCloudUsers.emptyState.tile.badge.new": "New",
+	"experiments.surfaceMcpToNewCloudUsers.emptyState.tile.badge.enabled": "Enabled",
+	"experiments.surfaceMcpToNewCloudUsers.emptyState.reminder": "You can enable this later in Settings > MCP.",
 	"settings.chatHub": "Chat",
 	"settings.chatHub.providers.fetching.error": "Error fetching chat provider settings",
 	"settings.chatHub.providers.updated.success": "Chat provider settings updated",
@@ -5413,10 +5451,17 @@
 	"instanceAi.error.title": "Something went wrong",
 	"instanceAi.error.technicalDetails": "Technical details",
 	"instanceAi.artifactsPanel.title": "Artifacts",
+	"instanceAi.artifactsPanel.showPreview": "Show artifacts preview",
+	"instanceAi.artifactsPanel.hidePreview": "Hide artifacts preview",
+	"instanceAi.artifactsPanel.showPanel": "Show lists panel",
+	"instanceAi.artifactsPanel.pinPanel": "Pin panel",
+	"instanceAi.artifactsPanel.unpinPanel": "Unpin panel",
 	"instanceAi.artifactsPanel.noArtifacts": "No artifacts yet",
-	"instanceAi.artifactsPanel.tasks": "Tasks",
+	"instanceAi.artifactsPanel.openArtifact": "Open {name}",
+	"instanceAi.artifactsPanel.tasks": "To-do list",
 	"instanceAi.artifactsPanel.openWorkflow": "Open",
 	"instanceAi.artifactsPanel.archived": "Archived",
+	"instanceAi.previewTabBar.expand": "Expand panel",
 	"instanceAi.previewTabBar.collapse": "Collapse panel",
 	"instanceAi.previewTabBar.openInEditor": "Open in editor",
 	"instanceAi.previewTabBar.openWorkflowInEditor": "Open workflow in editor",
diff --git a/packages/frontend/@n8n/stores/src/constants.ts b/packages/frontend/@n8n/stores/src/constants.ts
index b7061c50aec..1cdb4f155dc 100644
--- a/packages/frontend/@n8n/stores/src/constants.ts
+++ b/packages/frontend/@n8n/stores/src/constants.ts
@@ -52,6 +52,7 @@ export const STORES = {
 	CHAT_HUB_PANEL: 'chatHubPanel',
 	EXPERIMENT_EMPTY_STATE_BUILDER_PROMPT: 'emptyStateBuilderPrompt',
 	EXPERIMENT_CREDENTIALS_APP_SELECTION: 'credentialsAppSelection',
+	EXPERIMENT_SURFACE_MCP_TO_NEW_CLOUD_USERS: 'surfaceMcpToNewCloudUsers',
 	SETUP_PANEL: 'setupPanel',
 	FOCUSED_NODES: 'focusedNodes',
 	FAVORITES: 'favorites',
diff --git a/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.test.ts b/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.test.ts
index 2176f7207f0..2f78b2f5c59 100644
--- a/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.test.ts
+++ b/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.test.ts
@@ -6,10 +6,16 @@ import { useUsersStore } from '@/features/settings/users/users.store';
 import { useProjectsStore } from '@/features/collaboration/projects/projects.store';
 import { useSourceControlStore } from '@/features/integrations/sourceControl.ee/sourceControl.store';
 import { useRecommendedTemplatesStore } from '@/features/workflows/templates/recommendations/recommendedTemplates.store';
+import { useReadyToRunStore } from '@/features/workflows/readyToRun/stores/readyToRun.store';
 import { useBannersStore } from '@/features/shared/banners/banners.store';
 import userEvent from '@testing-library/user-event';
 import type { IUser } from '@n8n/rest-api-client/api/users';
 
+const surfaceMcpEmptyState = vi.hoisted(() => ({
+	showTile: false,
+	showReminder: false,
+}));
+
 vi.mock('vue-router', () => ({
 	useRouter: () => ({
 		push: vi.fn(),
@@ -23,6 +29,16 @@ vi.mock('vue-router', () => ({
 	},
 }));
 
+vi.mock('@/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState', async () => {
+	const { computed } = await import('vue');
+	return {
+		useSurfaceMcpEmptyState: vi.fn(() => ({
+			showTile: computed(() => surfaceMcpEmptyState.showTile),
+			showReminder: computed(() => surfaceMcpEmptyState.showReminder),
+		})),
+	};
+});
+
 const renderComponent = createComponentRenderer(EmptyStateLayout, {
 	pinia: createTestingPinia(),
 	global: {
@@ -33,6 +49,12 @@ const renderComponent = createComponentRenderer(EmptyStateLayout, {
 			ReadyToRunButton: {
 				template: '<button data-test-id="ready-to-run-button">Ready to Run</button>',
 			},
+			SurfaceMcpEmptyStateTile: {
+				template: '<div data-test-id="mcp-onboarding-card" />',
+			},
+			SurfaceMcpEmptyStateReminder: {
+				template: '<div data-test-id="mcp-onboarding-reminder" />',
+			},
 		},
 	},
 });
@@ -44,6 +66,7 @@ describe('EmptyStateLayout', () => {
 	let recommendedTemplatesStore: ReturnType<
 		typeof mockedStore<typeof useRecommendedTemplatesStore>
 	>;
+	let readyToRunStore: ReturnType<typeof mockedStore<typeof useReadyToRunStore>>;
 	let bannersStore: ReturnType<typeof mockedStore<typeof useBannersStore>>;
 
 	beforeEach(() => {
@@ -51,6 +74,7 @@ describe('EmptyStateLayout', () => {
 		projectsStore = mockedStore(useProjectsStore);
 		sourceControlStore = mockedStore(useSourceControlStore);
 		recommendedTemplatesStore = mockedStore(useRecommendedTemplatesStore);
+		readyToRunStore = mockedStore(useReadyToRunStore);
 		bannersStore = mockedStore(useBannersStore);
 
 		usersStore.currentUser = {
@@ -76,6 +100,9 @@ describe('EmptyStateLayout', () => {
 		} as unknown as ReturnType<typeof useSourceControlStore>['preferences'];
 
 		bannersStore.bannersHeight = 0;
+		readyToRunStore.userCanClaimOpenAiCredits = false;
+		surfaceMcpEmptyState.showTile = false;
+		surfaceMcpEmptyState.showReminder = false;
 
 		// Default: feature disabled (control variant)
 		recommendedTemplatesStore.isFeatureEnabled = false;
@@ -166,6 +193,35 @@ describe('EmptyStateLayout', () => {
 			expect(getByTestId('new-workflow-card')).toBeInTheDocument();
 		});
 
+		it('renders Surface MCP empty-state insertion components when enabled', () => {
+			surfaceMcpEmptyState.showTile = true;
+			surfaceMcpEmptyState.showReminder = true;
+
+			const { getByTestId } = renderComponent();
+
+			expect(getByTestId('mcp-onboarding-card')).toBeInTheDocument();
+			expect(getByTestId('mcp-onboarding-reminder')).toBeInTheDocument();
+		});
+
+		it('should render ready-to-run card when user can claim OpenAI credits and MCP tile is hidden', () => {
+			readyToRunStore.userCanClaimOpenAiCredits = true;
+
+			const { getByTestId } = renderComponent();
+
+			expect(getByTestId('ready-to-run-card')).toBeInTheDocument();
+		});
+
+		it('should hide ready-to-run card when Surface MCP tile is shown', () => {
+			readyToRunStore.userCanClaimOpenAiCredits = true;
+			surfaceMcpEmptyState.showTile = true;
+
+			const { queryByTestId, getByTestId } = renderComponent();
+
+			expect(queryByTestId('ready-to-run-card')).not.toBeInTheDocument();
+			expect(getByTestId('mcp-onboarding-card')).toBeInTheDocument();
+			expect(getByTestId('new-workflow-card')).toBeInTheDocument();
+		});
+
 		it('should emit click:add event when workflow card is clicked', async () => {
 			const { getByTestId, emitted } = renderComponent();
 
diff --git a/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.vue b/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.vue
index 3ef12f25cc3..f6b82332746 100644
--- a/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.vue
+++ b/packages/frontend/editor-ui/src/app/components/layouts/EmptyStateLayout.vue
@@ -7,6 +7,7 @@ import { useBannersStore } from '@/features/shared/banners/banners.store';
 import { useProjectsStore } from '@/features/collaboration/projects/projects.store';
 import { useProjectPages } from '@/features/collaboration/projects/composables/useProjectPages';
 import { useWorkflowsEmptyState } from '@/features/workflows/composables/useWorkflowsEmptyState';
+import { useSurfaceMcpEmptyState } from '@/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState';
 import { useEmptyStateBuilderPromptStore } from '@/experiments/emptyStateBuilderPrompt/stores/emptyStateBuilderPrompt.store';
 import { useCredentialsAppSelectionStore } from '@/experiments/credentialsAppSelection/stores/credentialsAppSelection.store';
 import { useReadyToRunStore } from '@/features/workflows/readyToRun/stores/readyToRun.store';
@@ -14,6 +15,8 @@ import RecommendedTemplatesSection from '@/features/workflows/templates/recommen
 import ReadyToRunButton from '@/features/workflows/readyToRun/components/ReadyToRunButton.vue';
 import EmptyStateBuilderPrompt from '@/experiments/emptyStateBuilderPrompt/components/EmptyStateBuilderPrompt.vue';
 import AppSelectionPage from '@/experiments/credentialsAppSelection/components/AppSelectionPage.vue';
+import SurfaceMcpEmptyStateReminder from '@/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateReminder.vue';
+import SurfaceMcpEmptyStateTile from '@/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.vue';
 
 const emit = defineEmits<{
 	'click:add': [];
@@ -38,13 +41,20 @@ const {
 	canCreateWorkflow,
 } = useWorkflowsEmptyState();
 
+const { showTile: showMcpTile, showReminder: showMcpReminder } = useSurfaceMcpEmptyState({
+	canCreateWorkflow: computed(() => Boolean(canCreateWorkflow.value)),
+	showAppSelection: computed(() => Boolean(showAppSelection.value)),
+	showBuilderPrompt: computed(() => Boolean(showBuilderPrompt.value)),
+	showRecommendedTemplatesInline: computed(() => Boolean(showRecommendedTemplatesInline.value)),
+});
+
 const addWorkflow = () => {
 	emit('click:add');
 };
 
 // Check if user can claim credits for ready-to-run
 const showReadyToRunCard = computed(() => {
-	return readyToRunStore.userCanClaimOpenAiCredits && canCreateWorkflow.value;
+	return readyToRunStore.userCanClaimOpenAiCredits && canCreateWorkflow.value && !showMcpTile.value;
 });
 
 const handleReadyToRunClick = async () => {
@@ -157,12 +167,20 @@ const handleAppSelectionContinue = () => {
 					<N8nText tag="p" size="large" color="text-base">
 						{{ emptyStateDescription }}
 					</N8nText>
+					<SurfaceMcpEmptyStateReminder v-if="showMcpReminder" />
 
 					<!-- Two cards or single card depending on ready-to-run availability -->
 					<div
 						v-if="canCreateWorkflow"
-						:class="[$style.actionCardsContainer, { [$style.singleCard]: !showReadyToRunCard }]"
+						:class="[
+							$style.actionCardsContainer,
+							{
+								[$style.singleCard]: !showReadyToRunCard && !showMcpTile,
+							},
+						]"
 					>
+						<SurfaceMcpEmptyStateTile v-if="showMcpTile" :class="$style.actionCard" />
+
 						<!-- Card 1: Try AI workflow (conditional) -->
 						<N8nCard
 							v-if="showReadyToRunCard"
@@ -286,6 +304,7 @@ const handleAppSelectionContinue = () => {
 }
 
 .actionCard {
+	position: relative;
 	width: 192px;
 	height: 230px;
 	text-align: center;
diff --git a/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.test.ts b/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.test.ts
index a03f2ed06dc..c51ead73644 100644
--- a/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.test.ts
+++ b/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.test.ts
@@ -28,6 +28,8 @@ import { useWorkflowsStore } from '@/app/stores/workflows.store';
 import { useUIStore } from '@/app/stores/ui.store';
 import { useToast } from '@/app/composables/useToast';
 import { useWorkflowHelpers } from '@/app/composables/useWorkflowHelpers';
+import { useWorkflowSaving } from '@/app/composables/useWorkflowSaving';
+import { useSettingsStore } from '@/app/stores/settings.store';
 import { captor, mock } from 'vitest-mock-extended';
 import { usePushConnectionStore } from '@/app/stores/pushConnection.store';
 import { createTestNode, createTestWorkflow } from '@/__tests__/mocks';
@@ -223,6 +225,16 @@ vi.mock('@/app/composables/useWorkflowHelpers', () => ({
 	}),
 }));
 
+vi.mock('@/app/composables/useWorkflowSaving', () => ({
+	useWorkflowSaving: vi.fn().mockReturnValue({
+		saveCurrentWorkflow: vi.fn().mockResolvedValue(true),
+		autoSaveWorkflow: vi.fn(),
+		cancelAutoSave: vi.fn(),
+		saveAsNewWorkflow: vi.fn(),
+		promptSaveUnsavedWorkflowChanges: vi.fn(),
+	}),
+}));
+
 vi.mock('@/app/composables/useNodeHelpers', () => ({
 	useNodeHelpers: vi.fn().mockReturnValue({
 		updateNodesExecutionIssues: vi.fn(),
@@ -415,6 +427,57 @@ describe('useRunWorkflow({ router })', () => {
 			expect(result).toEqual(mockExecutionResponse);
 		});
 
+		describe('save before execute behavior with N8N_WORKFLOWS_AUTOSAVE_DISABLED', () => {
+			let settingsStore: ReturnType<typeof useSettingsStore>;
+
+			beforeEach(() => {
+				settingsStore = useSettingsStore();
+				vi.mocked(pushConnectionStore).isConnected = true;
+				vi.mocked(workflowsStore).runWorkflow.mockResolvedValue({ executionId: '123' });
+				mockDocumentStore.serialize.mockReturnValue({
+					id: 'workflowId',
+					nodes: [],
+				} as unknown as WorkflowData);
+				vi.mocked(workflowsStore).getWorkflowRunData = null;
+			});
+
+			it('should save before execute when autosave is enabled and state is dirty', async () => {
+				vi.spyOn(settingsStore, 'isAutosaveEnabled', 'get').mockReturnValue(true);
+				vi.mocked(uiStore).stateIsDirty = true;
+				vi.mocked(workflowsStore).isWorkflowSaved = { '123': true };
+
+				const workflowSaving = useWorkflowSaving({ router });
+				const { runWorkflow } = useRunWorkflow({ router });
+				await runWorkflow({});
+
+				expect(workflowSaving.saveCurrentWorkflow).toHaveBeenCalledTimes(1);
+			});
+
+			it('should not save before execute when autosave is disabled and state is dirty', async () => {
+				vi.spyOn(settingsStore, 'isAutosaveEnabled', 'get').mockReturnValue(false);
+				vi.mocked(uiStore).stateIsDirty = true;
+				vi.mocked(workflowsStore).isWorkflowSaved = { '123': true };
+
+				const workflowSaving = useWorkflowSaving({ router });
+				const { runWorkflow } = useRunWorkflow({ router });
+				await runWorkflow({});
+
+				expect(workflowSaving.saveCurrentWorkflow).not.toHaveBeenCalled();
+			});
+
+			it('should save new workflow before execute even when autosave is disabled', async () => {
+				vi.spyOn(settingsStore, 'isAutosaveEnabled', 'get').mockReturnValue(false);
+				vi.mocked(uiStore).stateIsDirty = false;
+				vi.mocked(workflowsStore).isWorkflowSaved = {};
+
+				const workflowSaving = useWorkflowSaving({ router });
+				const { runWorkflow } = useRunWorkflow({ router });
+				await runWorkflow({});
+
+				expect(workflowSaving.saveCurrentWorkflow).toHaveBeenCalledTimes(1);
+			});
+		});
+
 		it('should prevent execution and show error when binary mode is "combined" with filesystem mode "default"', async () => {
 			const pinia = createTestingPinia({ stubActions: false });
 			setActivePinia(pinia);
diff --git a/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.ts b/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.ts
index a36702a0b59..94019aeb759 100644
--- a/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.ts
+++ b/packages/frontend/editor-ui/src/app/composables/useRunWorkflow.ts
@@ -161,7 +161,8 @@ export function useRunWorkflow(useRunWorkflowOpts: {
 
 			const runData = workflowsStore.getWorkflowRunData;
 
-			if (uiStore.stateIsDirty || !workflowsStore.isWorkflowSaved[workflowsStore.workflowId]) {
+			const isNewWorkflow = !workflowsStore.isWorkflowSaved[workflowsStore.workflowId];
+			if (isNewWorkflow || (uiStore.stateIsDirty && settingsStore.isAutosaveEnabled)) {
 				await workflowSaving.saveCurrentWorkflow();
 			}
 
diff --git a/packages/frontend/editor-ui/src/app/composables/useSidebarLayout.ts b/packages/frontend/editor-ui/src/app/composables/useSidebarLayout.ts
index b4ae97c85a3..c0b05da50cd 100644
--- a/packages/frontend/editor-ui/src/app/composables/useSidebarLayout.ts
+++ b/packages/frontend/editor-ui/src/app/composables/useSidebarLayout.ts
@@ -1,6 +1,9 @@
 import { computed, ref, toRef } from 'vue';
 import { useUIStore } from '../stores/ui.store';
 
+// Matches `$sidebar-width` in `app/css/_variables.scss`.
+export const COLLAPSED_MAIN_SIDEBAR_WIDTH = 42;
+
 export function useSidebarLayout() {
 	const uiStore = useUIStore();
 	const isCollapsed = computed(() => uiStore.sidebarMenuCollapsed ?? false);
diff --git a/packages/frontend/editor-ui/src/app/constants/experiments.ts b/packages/frontend/editor-ui/src/app/constants/experiments.ts
index 653add26191..35c42eb60a0 100644
--- a/packages/frontend/editor-ui/src/app/constants/experiments.ts
+++ b/packages/frontend/editor-ui/src/app/constants/experiments.ts
@@ -102,6 +102,14 @@ export const AA_EXPERIMENT_CHECK = createExperiment('078_experiment_check_aa');
 export const CHAT_HUB_SEMANTIC_SEARCH_EXPERIMENT = createExperiment('077_chat_hub_semantic_search');
 
 export const FLOATING_CHAT_HUB_PANEL_EXPERIMENT = createExperiment('078_floating_chat_hub_panel');
+export const SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT = createExperiment(
+	'081_surface_mcp_to_new_cloud_users',
+	{
+		control: 'control',
+		variant1: 'variant-1',
+		variant2: 'variant-2',
+	},
+);
 
 export const EXPERIMENTS_TO_TRACK = [
 	EXTRA_TEMPLATE_LINKS_EXPERIMENT.name,
@@ -129,4 +137,5 @@ export const EXPERIMENTS_TO_TRACK = [
 	AA_EXPERIMENT_CHECK.name,
 	CHAT_HUB_SEMANTIC_SEARCH_EXPERIMENT.name,
 	FLOATING_CHAT_HUB_PANEL_EXPERIMENT.name,
+	SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.name,
 ];
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpBridgeGraphic.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpBridgeGraphic.vue
new file mode 100644
index 00000000000..07b925d856d
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpBridgeGraphic.vue
@@ -0,0 +1,434 @@
+<script setup lang="ts">
+import { N8nIcon } from '@n8n/design-system';
+import { computed } from 'vue';
+
+type Size = 'hero' | 'inline' | 'tile';
+
+const props = withDefaults(
+	defineProps<{
+		size?: Size;
+		ariaLabel?: string;
+	}>(),
+	{
+		size: 'hero',
+		ariaLabel: 'MCP connects n8n with AI agents',
+	},
+);
+
+const isTile = computed(() => props.size === 'tile');
+const isHero = computed(() => props.size === 'hero');
+</script>
+
+<template>
+	<div
+		:class="[$style.bridge, $style[`bridge--${size}`]]"
+		role="img"
+		:aria-label="ariaLabel"
+		data-test-id="surface-mcp-bridge-graphic"
+	>
+		<template v-if="!isTile">
+			<!-- Right node: n8n logo -->
+			<div :class="[$style.node, $style.nodeN8n]" data-test-id="surface-mcp-bridge-n8n-logo">
+				<svg viewBox="0 0 32 26" xmlns="http://www.w3.org/2000/svg" fill="none" aria-hidden="true">
+					<path
+						fill-rule="evenodd"
+						clip-rule="evenodd"
+						d="M27.2 11.3955C26.4903 11.3959 25.8006 11.1603 25.2394 10.7259C24.6783 10.2914 24.2774 9.68271 24.1 8.99555H20.433C20.0543 8.9956 19.6879 9.12999 19.3989 9.3748C19.11 9.61962 18.9173 9.95899 18.855 10.3325L18.723 11.1225C18.6018 11.8478 18.2346 12.5092 17.683 12.9955C18.2348 13.4821 18.6021 14.1439 18.723 14.8695L18.855 15.6585C18.9173 16.0321 19.11 16.3715 19.3989 16.6163C19.6879 16.8611 20.0543 16.9955 20.433 16.9955H20.901C21.0968 16.2424 21.5603 15.5864 22.2047 15.1502C22.8491 14.714 23.6303 14.5275 24.4023 14.6255C25.1743 14.7236 25.8841 15.0995 26.399 15.6829C26.9139 16.2663 27.1987 17.0174 27.2 17.7955C27.2015 18.5755 26.9182 19.3292 26.4031 19.9149C25.8881 20.5006 25.1769 20.8781 24.4031 20.9764C23.6294 21.0746 22.8464 20.8869 22.2013 20.4485C21.5562 20.0101 21.0935 19.3511 20.9 18.5955H20.433C19.6756 18.5954 18.9428 18.3267 18.3649 17.837C17.787 17.3474 17.4015 16.6687 17.277 15.9215L17.145 15.1325C17.0828 14.759 16.89 14.4196 16.6011 14.1748C16.3121 13.93 15.9457 13.7956 15.567 13.7955H14.299C14.1214 14.4823 13.7206 15.0907 13.1596 15.525C12.5987 15.9593 11.9094 16.1949 11.2 16.1949C10.4906 16.1949 9.80129 15.9593 9.24036 15.525C8.67943 15.0907 8.27866 14.4823 8.10101 13.7955H6.29901C6.1032 14.5487 5.63975 15.2047 4.99533 15.6409C4.35091 16.0771 3.56967 16.2636 2.7977 16.1656C2.02573 16.0675 1.31592 15.6916 0.800999 15.1082C0.286083 14.5247 0.00133389 13.7737 6.20563e-06 12.9955C-0.00152906 12.2156 0.281849 11.4619 0.796882 10.8762C1.31191 10.2905 2.02314 9.91299 2.79689 9.81474C3.57064 9.71649 4.35363 9.90421 4.99871 10.3426C5.6438 10.781 6.10655 11.44 6.30001 12.1955H8.10001C8.27697 11.5079 8.67758 10.8985 9.23878 10.4635C9.79998 10.0284 10.4899 9.79229 11.2 9.79229C11.9101 9.79229 12.6 10.0284 13.1612 10.4635C13.7224 10.8985 14.123 11.5079 14.3 12.1955H15.567C15.9457 12.1955 16.3121 12.0611 16.6011 11.8163C16.89 11.5715 17.0828 11.2321 17.145 10.8585L17.277 10.0685C17.4017 9.32161 17.7873 8.64311 18.3652 8.15368C18.943 7.66425 19.6757 7.39562 20.433 7.39555H24.101C24.2968 6.64242 24.7603 5.9864 25.4047 5.5502C26.0491 5.114 26.8303 4.92747 27.6023 5.02552C28.3743 5.12356 29.0841 5.49945 29.599 6.0829C30.1139 6.66634 30.3987 7.41738 30.4 8.19555C30.4 9.04424 30.0629 9.85817 29.4627 10.4583C28.8626 11.0584 28.0487 11.3955 27.2 11.3955ZM27.2 9.79555C27.6244 9.79555 28.0313 9.62698 28.3314 9.32692C28.6314 9.02686 28.8 8.61989 28.8 8.19555C28.8 7.7712 28.6314 7.36423 28.3314 7.06418C28.0313 6.76412 27.6244 6.59555 27.2 6.59555C26.7757 6.59555 26.3687 6.76412 26.0686 7.06418C25.7686 7.36423 25.6 7.7712 25.6 8.19555C25.6 8.61989 25.7686 9.02686 26.0686 9.32692C26.3687 9.62698 26.7757 9.79555 27.2 9.79555ZM3.20001 14.5955C3.62435 14.5955 4.03132 14.427 4.33138 14.1269C4.63144 13.8269 4.80001 13.4199 4.80001 12.9955C4.80001 12.5712 4.63144 12.1642 4.33138 11.8642C4.03132 11.5641 3.62435 11.3955 3.20001 11.3955C2.77566 11.3955 2.36869 11.5641 2.06864 11.8642C1.76858 12.1642 1.60001 12.5712 1.60001 12.9955C1.60001 13.4199 1.76858 13.8269 2.06864 14.1269C2.36869 14.427 2.77566 14.5955 3.20001 14.5955ZM12.8 12.9955C12.8 13.2057 12.7586 13.4137 12.6782 13.6078C12.5978 13.802 12.48 13.9783 12.3314 14.1269C12.1828 14.2755 12.0064 14.3933 11.8123 14.4738C11.6182 14.5542 11.4101 14.5955 11.2 14.5955C10.9899 14.5955 10.7818 14.5542 10.5877 14.4738C10.3936 14.3933 10.2172 14.2755 10.0686 14.1269C9.92006 13.9783 9.80221 13.802 9.7218 13.6078C9.64139 13.4137 9.60001 13.2057 9.60001 12.9955C9.60001 12.5712 9.76858 12.1642 10.0686 11.8642C10.3687 11.5641 10.7757 11.3955 11.2 11.3955C11.6244 11.3955 12.0313 11.5641 12.3314 11.8642C12.6314 12.1642 12.8 12.5712 12.8 12.9955ZM25.6 17.7955C25.6 18.0057 25.5586 18.2137 25.4782 18.4078C25.3978 18.602 25.28 18.7783 25.1314 18.9269C24.9828 19.0755 24.8064 19.1933 24.6123 19.2738C24.4182 19.3542 24.2101 19.3955 24 19.3955C23.7899 19.3955 23.5818 19.3542 23.3877 19.2738C23.1936 19.1933 23.0172 19.0755 22.8686 18.9269C22.7201 18.7783 22.6022 18.602 22.5218 18.4078C22.4414 18.2137 22.4 18.0057 22.4 17.7955C22.4 17.3712 22.5686 16.9642 22.8686 16.6642C23.1687 16.3641 23.5757 16.1955 24 16.1955C24.4244 16.1955 24.8313 16.3641 25.1314 16.6642C25.4314 16.9642 25.6 17.3712 25.6 17.7955Z"
+						fill="currentColor"
+					/>
+				</svg>
+			</div>
+
+			<!-- Connector: agents -> n8n -->
+			<span
+				:class="[$style.connector, $style.connectorToN8n, { [$style.connectorAnimated]: isHero }]"
+				aria-hidden="true"
+			>
+				<svg viewBox="0 0 64 8" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg">
+					<line
+						x1="0"
+						y1="4"
+						x2="64"
+						y2="4"
+						stroke="currentColor"
+						stroke-width="1.5"
+						stroke-linecap="round"
+						stroke-dasharray="2 5"
+					/>
+				</svg>
+			</span>
+			<!-- Left node: stacked agent marks -->
+			<div :class="[$style.node, $style.nodeAgents]" data-test-id="surface-mcp-bridge-agent-logos">
+				<span :class="[$style.agent, $style.agentStacked, $style.agentClaude]">
+					<svg
+						:class="$style.agentIcon"
+						viewBox="0 0 24 24"
+						fill="none"
+						xmlns="http://www.w3.org/2000/svg"
+						data-test-id="surface-mcp-bridge-claude-logo"
+					>
+						<path
+							d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 0 1-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z"
+							fill="#D97757"
+						/>
+					</svg>
+				</span>
+				<span :class="[$style.agent, $style.agentStacked, $style.agentCodex]">
+					<svg
+						:class="$style.agentIcon"
+						viewBox="0 0 24 24"
+						xmlns="http://www.w3.org/2000/svg"
+						data-test-id="surface-mcp-bridge-codex-logo"
+					>
+						<path
+							d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z"
+							fill="#fff"
+						/>
+						<path
+							d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z"
+							fill="url(#surface-mcp-codex-gradient)"
+						/>
+						<defs>
+							<linearGradient
+								id="surface-mcp-codex-gradient"
+								gradientUnits="userSpaceOnUse"
+								x1="12"
+								x2="12"
+								y1="3"
+								y2="21"
+							>
+								<stop stop-color="#B1A7FF" />
+								<stop offset=".5" stop-color="#7A9DFF" />
+								<stop offset="1" stop-color="#3941FF" />
+							</linearGradient>
+						</defs>
+					</svg>
+				</span>
+				<span :class="[$style.agent, $style.agentStacked, $style.agentCursor]">
+					<svg
+						:class="$style.agentIcon"
+						viewBox="0 0 24 24"
+						fill="currentColor"
+						fill-rule="evenodd"
+						xmlns="http://www.w3.org/2000/svg"
+						data-test-id="surface-mcp-bridge-cursor-logo"
+					>
+						<path
+							d="M22.106 5.68L12.5.135a.998.998 0 00-.998 0L1.893 5.68a.84.84 0 00-.419.726v11.186c0 .3.16.577.42.727l9.607 5.547a.999.999 0 00.998 0l9.608-5.547a.84.84 0 00.42-.727V6.407a.84.84 0 00-.42-.726zm-.603 1.176L12.228 22.92c-.063.108-.228.064-.228-.061V12.34a.59.59 0 00-.295-.51l-9.11-5.26c-.107-.062-.063-.228.062-.228h18.55c.264 0 .428.286.296.514z"
+						/>
+					</svg>
+				</span>
+				<span :class="[$style.agent, $style.agentOpenAi]">
+					<svg
+						:class="$style.agentIcon"
+						viewBox="0 0 24 24"
+						fill="currentColor"
+						fill-rule="evenodd"
+						xmlns="http://www.w3.org/2000/svg"
+						data-test-id="surface-mcp-bridge-openai-logo"
+					>
+						<path
+							d="M9.205 8.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357 1.356-.523 2.117-.523 2.854 0 4.662 2.212 4.662 4.566 0 .167 0 .357-.024.547l-4.71-2.759a.797.797 0 00-.856 0l-5.97 3.473zm10.609 8.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473 1.95-1.118a.433.433 0 01.476 0l4.543 2.617c1.309.76 2.189 2.378 2.189 3.948 0 1.808-1.07 3.473-2.76 4.163zM7.802 12.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545 1.95-4.472 4.591-4.472 1 0 1.927.333 2.712.928L8.23 5.067c-.285.166-.428.404-.428.737v6.898zM12 15.128l-2.795-1.57v-3.33L12 8.658l2.795 1.57v3.33L12 15.128zm1.796 7.23c-1 0-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974 1.142c.167.095.238.238.238.428v5.233c0 2.545-1.974 4.472-4.614 4.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482 4.482 0 014.21 6.327v5.423c0 .333.143.571.428.738l5.947 3.449-1.95 1.118a.432.432 0 01-.476 0zm-.262 3.9c-2.688 0-4.662-2.021-4.662-4.519 0-.19.024-.38.047-.57l4.686 2.71c.286.167.571.167.856 0l5.97-3.448v2.26c0 .19-.07.333-.237.428l-4.543 2.616c-.619.357-1.356.523-2.117.523zm5.899 2.83a5.947 5.947 0 005.827-4.756C22.287 18.339 24 15.84 24 13.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498 0-3.401-2.759-5.947-5.946-5.947-.642 0-1.26.095-1.88.31A5.962 5.962 0 0010.205 0a5.947 5.947 0 00-5.827 4.757C1.713 5.447 0 7.945 0 10.49c0 1.666.713 3.283 1.998 4.448-.119.5-.19 1-.19 1.499 0 3.401 2.759 5.946 5.946 5.946.642 0 1.26-.095 1.88-.309a5.96 5.96 0 004.162 1.713z"
+						/>
+					</svg>
+				</span>
+			</div>
+		</template>
+
+		<!-- Tile variant: simplified center MCP icon flanked by 2 dots -->
+		<template v-else>
+			<span :class="[$style.tileDot, $style.tileDotLeft]" aria-hidden="true" />
+			<span :class="$style.tileConnector" aria-hidden="true">
+				<svg viewBox="0 0 24 8" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg">
+					<line
+						x1="0"
+						y1="4"
+						x2="24"
+						y2="4"
+						stroke="currentColor"
+						stroke-width="1.25"
+						stroke-linecap="round"
+						stroke-dasharray="2 4"
+					/>
+				</svg>
+			</span>
+			<div :class="[$style.node, $style.nodeMcp, $style.tileMcp]">
+				<span :class="$style.mcpHalo" aria-hidden="true" />
+				<N8nIcon icon="mcp" :class="$style.mcpIcon" />
+			</div>
+			<span :class="$style.tileConnector" aria-hidden="true">
+				<svg viewBox="0 0 24 8" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg">
+					<line
+						x1="0"
+						y1="4"
+						x2="24"
+						y2="4"
+						stroke="currentColor"
+						stroke-width="1.25"
+						stroke-linecap="round"
+						stroke-dasharray="2 4"
+					/>
+				</svg>
+			</span>
+			<span :class="[$style.tileDot, $style.tileDotRight]" aria-hidden="true" />
+		</template>
+	</div>
+</template>
+
+<style lang="scss" module>
+@use '@n8n/design-system/css/mixins/motion.scss' as motion;
+
+.bridge {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: var(--spacing--3xs);
+	color: var(--icon-color--strong);
+}
+
+// --- Sizes -----------------------------------------------------------------
+
+.bridge--hero {
+	gap: var(--spacing--2xs);
+
+	.node {
+		width: 56px;
+		height: 56px;
+	}
+
+	.nodeMcp {
+		width: 72px;
+		height: 72px;
+	}
+
+	.nodeN8n svg {
+		width: 32px;
+		height: auto;
+	}
+
+	.mcpIcon {
+		font-size: 36px;
+	}
+
+	.connector {
+		width: 96px;
+	}
+
+	.agent {
+		width: 38px;
+		height: 38px;
+	}
+
+	.agentStacked {
+		margin-right: -12px;
+	}
+
+	.agentIcon {
+		width: 18px;
+		height: 18px;
+	}
+}
+
+.bridge--inline {
+	gap: var(--spacing--4xs);
+
+	.node {
+		width: 28px;
+		height: 28px;
+	}
+
+	.nodeMcp {
+		width: 36px;
+		height: 36px;
+	}
+
+	.nodeN8n svg {
+		width: 18px;
+		height: auto;
+	}
+
+	.mcpIcon {
+		font-size: 20px;
+	}
+
+	.connector {
+		width: 24px;
+	}
+
+	.agent {
+		width: 22px;
+		height: 22px;
+	}
+
+	.agentStacked {
+		margin-right: -7px;
+	}
+
+	.agentIcon {
+		width: 11px;
+		height: 11px;
+	}
+}
+
+.bridge--tile {
+	gap: var(--spacing--4xs);
+
+	.tileMcp {
+		width: 40px;
+		height: 40px;
+	}
+
+	.mcpIcon {
+		font-size: 22px;
+	}
+}
+
+// --- Nodes -----------------------------------------------------------------
+
+.node {
+	position: relative;
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	flex-shrink: 0;
+	border-radius: var(--radius--full);
+}
+
+.nodeN8n {
+	order: 3;
+	background: var(--background--surface);
+	border: 1px solid var(--border-color--subtle);
+	color: var(--color--orange-500);
+	box-shadow: 0 1px 2px rgb(0 0 0 / 4%);
+}
+
+.nodeMcp {
+	background: var(--background--surface);
+	border: 1px solid var(--border-color--subtle);
+	color: var(--icon-color--strong);
+	box-shadow: 0 2px 8px rgb(234 75 113 / 8%);
+	z-index: 1;
+}
+
+.mcpHalo {
+	position: absolute;
+	inset: -4px;
+	border-radius: var(--radius--full);
+	background: radial-gradient(circle, rgb(234 152 75 / 18%) 0%, rgb(234 152 75 / 0%) 70%);
+	z-index: -1;
+	pointer-events: none;
+}
+
+.nodeAgents {
+	order: 1;
+	display: inline-flex;
+	align-items: center;
+	background: transparent;
+	border: 0;
+	width: auto !important; // override .node sizing - this is a stack, not a single circle
+	height: auto !important;
+	border-radius: 0;
+}
+
+.agent {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	border-radius: var(--radius--full);
+	background: var(--background--surface);
+	border: 1px solid var(--border-color--subtle);
+	box-shadow: 0 1px 2px rgb(0 0 0 / 4%);
+	color: var(--icon-color--strong);
+}
+
+.agentClaude {
+	z-index: 4;
+}
+
+.agentCodex {
+	z-index: 3;
+}
+
+.agentCursor {
+	z-index: 2;
+}
+
+.agentOpenAi {
+	color: var(--icon-color--strong);
+}
+
+// --- Connectors ------------------------------------------------------------
+
+.connector {
+	display: inline-flex;
+	align-items: center;
+	height: 8px;
+	color: var(--border-color--strong);
+
+	svg {
+		display: block;
+		width: 100%;
+		height: 100%;
+		overflow: visible;
+	}
+
+	line {
+		stroke-dashoffset: 0;
+	}
+}
+
+.connectorToN8n {
+	order: 2;
+}
+
+.connectorAnimated line {
+	animation: dashFlow 1.6s linear infinite;
+
+	@media (prefers-reduced-motion: reduce) {
+		animation: none;
+	}
+}
+
+@keyframes dashFlow {
+	from {
+		stroke-dashoffset: 0;
+	}
+	to {
+		stroke-dashoffset: -14;
+	}
+}
+
+// --- Tile variant pieces ---------------------------------------------------
+
+.tileDot {
+	display: inline-block;
+	width: 8px;
+	height: 8px;
+	border-radius: var(--radius--full);
+	flex-shrink: 0;
+}
+
+.tileDotLeft {
+	background: var(--color--orange-500);
+	box-shadow: 0 0 0 3px rgb(234 152 75 / 16%);
+}
+
+.tileDotRight {
+	background: var(--icon-color--strong);
+	box-shadow: 0 0 0 3px rgb(0 0 0 / 6%);
+}
+
+.tileConnector {
+	display: inline-flex;
+	align-items: center;
+	width: 18px;
+	height: 8px;
+	color: var(--border-color--strong);
+
+	svg {
+		display: block;
+		width: 100%;
+		height: 100%;
+	}
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateReminder.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateReminder.vue
new file mode 100644
index 00000000000..8fae2a07ab9
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateReminder.vue
@@ -0,0 +1,23 @@
+<script setup lang="ts">
+import { N8nText } from '@n8n/design-system';
+import { useI18n } from '@n8n/i18n';
+
+const i18n = useI18n();
+</script>
+
+<template>
+	<N8nText
+		size="small"
+		color="text-light"
+		data-test-id="mcp-onboarding-reminder"
+		:class="$style.reminder"
+	>
+		{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.emptyState.reminder') }}
+	</N8nText>
+</template>
+
+<style lang="scss" module>
+.reminder {
+	margin-top: var(--spacing--xs);
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.test.ts
new file mode 100644
index 00000000000..2cf7846b72d
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.test.ts
@@ -0,0 +1,76 @@
+import { createComponentRenderer } from '@/__tests__/render';
+import { mockedStore } from '@/__tests__/utils';
+import { useUIStore } from '@/app/stores/ui.store';
+import { SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT } from '@/app/constants/experiments';
+import { useMCPStore } from '@/features/ai/mcpAccess/mcp.store';
+import { createTestingPinia } from '@pinia/testing';
+import userEvent from '@testing-library/user-event';
+import { useSurfaceMcpToNewCloudUsersStore } from '../stores/surfaceMcpToNewCloudUsers.store';
+import SurfaceMcpEmptyStateTile from './SurfaceMcpEmptyStateTile.vue';
+
+const renderComponent = createComponentRenderer(SurfaceMcpEmptyStateTile);
+
+describe('SurfaceMcpEmptyStateTile', () => {
+	let pinia: ReturnType<typeof createTestingPinia>;
+	let uiStore: ReturnType<typeof mockedStore<typeof useUIStore>>;
+	let mcpStore: ReturnType<typeof mockedStore<typeof useMCPStore>>;
+	let surfaceMcpStore: ReturnType<typeof mockedStore<typeof useSurfaceMcpToNewCloudUsersStore>>;
+
+	beforeEach(() => {
+		pinia = createTestingPinia();
+		uiStore = mockedStore(useUIStore);
+		mcpStore = mockedStore(useMCPStore);
+		surfaceMcpStore = mockedStore(useSurfaceMcpToNewCloudUsersStore);
+
+		mcpStore.mcpAccessEnabled = false;
+		surfaceMcpStore.currentVariant = SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1;
+	});
+
+	it('renders variant 1 CTA with a New badge', () => {
+		surfaceMcpStore.currentVariant = SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1;
+
+		const { getByTestId, queryByText } = renderComponent({ pinia });
+		const card = getByTestId('mcp-onboarding-card');
+
+		expect(card).toHaveTextContent('Build from your assistant');
+		expect(getByTestId('mcp-onboarding-badge')).toHaveTextContent('New');
+		expect(getByTestId('mcp-tile-logo-row')).toBeInTheDocument();
+		expect(queryByText(/Connect MCP clients like Claude Code and Cursor/)).not.toBeInTheDocument();
+	});
+
+	it('renders variant 2 CTA with a New badge', () => {
+		surfaceMcpStore.currentVariant = SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2;
+
+		const { getByTestId, queryByText } = renderComponent({ pinia });
+		const card = getByTestId('mcp-onboarding-card');
+
+		expect(card).toHaveTextContent('Connect to your AI');
+		expect(getByTestId('mcp-onboarding-badge')).toHaveTextContent('New');
+		expect(getByTestId('mcp-tile-logo-row')).toBeInTheDocument();
+		expect(queryByText(/Connect MCP clients like Claude Code and Cursor/)).not.toBeInTheDocument();
+	});
+
+	it('renders the Enabled badge when MCP access is enabled', () => {
+		mcpStore.mcpAccessEnabled = true;
+
+		const { getByTestId } = renderComponent({ pinia });
+
+		expect(getByTestId('mcp-onboarding-badge')).toHaveTextContent('Enabled');
+	});
+
+	it('opens the onboarding modal when clicked', async () => {
+		const user = userEvent.setup();
+		const { getByTestId } = renderComponent({ pinia });
+
+		await user.click(getByTestId('mcp-onboarding-card'));
+
+		expect(surfaceMcpStore.trackOpened).toHaveBeenCalledWith('tile', {
+			entryPoint: 'empty_state_tile',
+			mcpAccessEnabled: false,
+		});
+		expect(uiStore.openModalWithData).toHaveBeenCalledWith({
+			name: 'mcpOnboardingModal',
+			data: { surface: 'tile' },
+		});
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.vue
new file mode 100644
index 00000000000..82a81e922a0
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpEmptyStateTile.vue
@@ -0,0 +1,106 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { N8nCard, N8nIcon, N8nText } from '@n8n/design-system';
+import { useI18n, type BaseTextKey } from '@n8n/i18n';
+import { SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT } from '@/app/constants/experiments';
+import { useUIStore } from '@/app/stores/ui.store';
+import { useMCPStore } from '@/features/ai/mcpAccess/mcp.store';
+import { SURFACE_MCP_ONBOARDING_MODAL_KEY } from '../constants';
+import { useSurfaceMcpToNewCloudUsersStore } from '../stores/surfaceMcpToNewCloudUsers.store';
+import SurfaceMcpTileLogos from './SurfaceMcpTileLogos.vue';
+
+const i18n = useI18n();
+const uiStore = useUIStore();
+const mcpStore = useMCPStore();
+const surfaceMcpStore = useSurfaceMcpToNewCloudUsersStore();
+
+const ctaKey = computed<BaseTextKey>(() =>
+	surfaceMcpStore.currentVariant === SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2
+		? 'experiments.surfaceMcpToNewCloudUsers.emptyState.tile.variant2.cta'
+		: 'experiments.surfaceMcpToNewCloudUsers.emptyState.tile.variant1.cta',
+);
+
+const badgeKey = computed<BaseTextKey>(() =>
+	mcpStore.mcpAccessEnabled
+		? 'experiments.surfaceMcpToNewCloudUsers.emptyState.tile.badge.enabled'
+		: 'experiments.surfaceMcpToNewCloudUsers.emptyState.tile.badge.new',
+);
+
+function openOnboarding() {
+	surfaceMcpStore.trackOpened('tile', {
+		entryPoint: 'empty_state_tile',
+		mcpAccessEnabled: mcpStore.mcpAccessEnabled,
+	});
+	uiStore.openModalWithData({
+		name: SURFACE_MCP_ONBOARDING_MODAL_KEY,
+		data: { surface: 'tile' },
+	});
+}
+</script>
+
+<template>
+	<N8nCard
+		:class="$style.card"
+		hoverable
+		data-test-id="mcp-onboarding-card"
+		@click="openOnboarding"
+	>
+		<span
+			:class="[$style.badge, { [$style.badgeEnabled]: mcpStore.mcpAccessEnabled }]"
+			data-test-id="mcp-onboarding-badge"
+		>
+			<N8nIcon v-if="mcpStore.mcpAccessEnabled" icon="check" size="xsmall" :stroke-width="2.5" />
+			{{ i18n.baseText(badgeKey) }}
+		</span>
+		<div :class="$style.content">
+			<SurfaceMcpTileLogos />
+			<N8nText size="large" :bold="true" :class="$style.cta">
+				{{ i18n.baseText(ctaKey) }}
+			</N8nText>
+		</div>
+	</N8nCard>
+</template>
+
+<style lang="scss" module>
+.card {
+	position: relative;
+}
+
+.content {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	padding: var(--spacing--md);
+	gap: var(--spacing--sm);
+	width: 100%;
+}
+
+.cta {
+	letter-spacing: var(--letter-spacing--tight);
+}
+
+.badge {
+	position: absolute;
+	top: var(--spacing--3xs);
+	right: var(--spacing--3xs);
+	display: inline-flex;
+	align-items: center;
+	gap: var(--spacing--5xs);
+	padding: 2px var(--spacing--3xs);
+	border-radius: var(--radius--full);
+	background: var(--color--orange-100);
+	color: var(--color--orange-800);
+	font-size: var(--font-size--3xs);
+	font-weight: var(--font-weight--bold);
+	letter-spacing: var(--letter-spacing--wider);
+	text-transform: uppercase;
+	line-height: 1;
+	z-index: 1;
+}
+
+.badgeEnabled {
+	background: var(--color--green-100);
+	color: var(--color--green-800);
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.test.ts
new file mode 100644
index 00000000000..68b6ffe461a
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.test.ts
@@ -0,0 +1,116 @@
+import { createComponentRenderer } from '@/__tests__/render';
+import { mockedStore } from '@/__tests__/utils';
+import { useUIStore } from '@/app/stores/ui.store';
+import {
+	SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY,
+	SURFACE_MCP_ONBOARDING_MODAL_KEY,
+} from '@/experiments/surfaceMcpToNewCloudUsers/constants';
+import { useSurfaceMcpToNewCloudUsersStore } from '@/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store';
+import { MCP_SETTINGS_VIEW } from '@/features/ai/mcpAccess/mcp.constants';
+import { createTestingPinia } from '@pinia/testing';
+import userEvent from '@testing-library/user-event';
+import { defineComponent } from 'vue';
+import SurfaceMcpFirstOpenIntroModal from './SurfaceMcpFirstOpenIntroModal.vue';
+
+const ModalStub = defineComponent({
+	props: ['name', 'title', 'eventBus'],
+	template: `
+		<div :data-test-id="name">
+			<h1>{{ title }}</h1>
+			<slot name="content" />
+			<slot name="footer" />
+			<button data-test-id="surface-mcp-intro-generic-close" @click="eventBus.emit('closed')" />
+		</div>
+	`,
+});
+
+const RouterLinkStub = defineComponent({
+	props: ['to'],
+	template: '<a :data-route-name="to?.name"><slot /></a>',
+});
+
+const renderComponent = createComponentRenderer(SurfaceMcpFirstOpenIntroModal, {
+	global: {
+		stubs: {
+			Modal: ModalStub,
+			RouterLink: RouterLinkStub,
+		},
+	},
+});
+
+describe('SurfaceMcpFirstOpenIntroModal', () => {
+	let pinia: ReturnType<typeof createTestingPinia>;
+
+	beforeEach(() => {
+		pinia = createTestingPinia();
+
+		const uiStore = mockedStore(useUIStore);
+		const surfaceMcpStore = mockedStore(useSurfaceMcpToNewCloudUsersStore);
+
+		uiStore.openModalWithData = vi.fn();
+		uiStore.closeModal = vi.fn();
+		surfaceMcpStore.dismissFirstOpenModal = vi.fn();
+		surfaceMcpStore.trackDismissed = vi.fn();
+	});
+
+	it('renders the intro copy and both actions', () => {
+		const { getByText, getByTestId } = renderComponent({ pinia });
+
+		expect(getByText('Try MCP with Claude Code, Cursor, or Codex')).toBeInTheDocument();
+		expect(
+			getByText(
+				'Connect MCP clients like Claude Code and Cursor to build, run, and iterate on workflows in your instance.',
+			),
+		).toBeInTheDocument();
+		const settingsLink = getByTestId('surface-mcp-intro-settings-link');
+		expect(settingsLink).toHaveTextContent('Settings > Instance-level MCP');
+		expect(settingsLink).toHaveAttribute('data-route-name', MCP_SETTINGS_VIEW);
+		expect(getByTestId('surface-mcp-intro-skip-button')).toBeInTheDocument();
+		expect(getByTestId('surface-mcp-intro-try-button')).toBeInTheDocument();
+	});
+
+	it('closes the intro modal and opens the setup modal when the user clicks Try MCP', async () => {
+		const user = userEvent.setup();
+		const uiStore = mockedStore(useUIStore);
+		const surfaceMcpStore = mockedStore(useSurfaceMcpToNewCloudUsersStore);
+		const { getByTestId } = renderComponent({ pinia });
+
+		await user.click(getByTestId('surface-mcp-intro-try-button'));
+
+		expect(uiStore.closeModal).toHaveBeenCalledWith(SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY);
+		expect(uiStore.openModalWithData).toHaveBeenCalledWith({
+			name: SURFACE_MCP_ONBOARDING_MODAL_KEY,
+			data: { surface: 'first_open_modal' },
+		});
+		expect(surfaceMcpStore.dismissFirstOpenModal).not.toHaveBeenCalled();
+		expect(surfaceMcpStore.trackDismissed).not.toHaveBeenCalled();
+	});
+
+	it('dismisses the experiment when the user clicks Skip for now', async () => {
+		const user = userEvent.setup();
+		const uiStore = mockedStore(useUIStore);
+		const surfaceMcpStore = mockedStore(useSurfaceMcpToNewCloudUsersStore);
+		const { getByTestId } = renderComponent({ pinia });
+
+		await user.click(getByTestId('surface-mcp-intro-skip-button'));
+
+		expect(surfaceMcpStore.dismissFirstOpenModal).toHaveBeenCalled();
+		expect(surfaceMcpStore.trackDismissed).toHaveBeenCalledWith('first_open_modal');
+		expect(uiStore.closeModal).toHaveBeenCalledWith(SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY);
+		expect(uiStore.openModalWithData).not.toHaveBeenCalled();
+	});
+
+	it('treats a generic modal close as Skip for now', async () => {
+		const user = userEvent.setup();
+		const uiStore = mockedStore(useUIStore);
+		const surfaceMcpStore = mockedStore(useSurfaceMcpToNewCloudUsersStore);
+		const { getByTestId } = renderComponent({ pinia });
+
+		await user.click(getByTestId('surface-mcp-intro-generic-close'));
+
+		expect(surfaceMcpStore.dismissFirstOpenModal).toHaveBeenCalled();
+		expect(surfaceMcpStore.trackDismissed).toHaveBeenCalledWith('first_open_modal');
+		expect(uiStore.closeModal).not.toHaveBeenCalled();
+		expect(uiStore.openModalWithData).not.toHaveBeenCalled();
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.vue
new file mode 100644
index 00000000000..c552859c6a4
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpFirstOpenIntroModal.vue
@@ -0,0 +1,240 @@
+<script setup lang="ts">
+import Modal from '@/app/components/Modal.vue';
+import { useUIStore } from '@/app/stores/ui.store';
+import SurfaceMcpBridgeGraphic from '@/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpBridgeGraphic.vue';
+import {
+	SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY,
+	SURFACE_MCP_ONBOARDING_MODAL_KEY,
+} from '@/experiments/surfaceMcpToNewCloudUsers/constants';
+import { useSurfaceMcpToNewCloudUsersStore } from '@/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store';
+import { MCP_SETTINGS_VIEW } from '@/features/ai/mcpAccess/mcp.constants';
+import { N8nButton, N8nHeading, N8nLink, N8nText } from '@n8n/design-system';
+import { useI18n } from '@n8n/i18n';
+import type { BaseTextKey } from '@n8n/i18n';
+import { createEventBus } from '@n8n/utils/event-bus';
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
+import { I18nT } from 'vue-i18n';
+
+const props = defineProps<{
+	modalName?: string;
+}>();
+
+const i18n = useI18n();
+const uiStore = useUIStore();
+const surfaceMcpStore = useSurfaceMcpToNewCloudUsersStore();
+const modalBus = createEventBus();
+const exitMode = ref<'none' | 'skip' | 'try'>('none');
+
+const modalName = computed(() => props.modalName ?? SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY);
+
+function dismissExperiment() {
+	surfaceMcpStore.dismissFirstOpenModal();
+	surfaceMcpStore.trackDismissed('first_open_modal');
+}
+
+function handleSkip() {
+	if (exitMode.value !== 'none') {
+		return;
+	}
+
+	exitMode.value = 'skip';
+	dismissExperiment();
+	uiStore.closeModal(modalName.value);
+}
+
+function handleTryIt() {
+	if (exitMode.value !== 'none') {
+		return;
+	}
+
+	exitMode.value = 'try';
+	uiStore.closeModal(modalName.value);
+	uiStore.openModalWithData({
+		name: SURFACE_MCP_ONBOARDING_MODAL_KEY,
+		data: { surface: 'first_open_modal' },
+	});
+}
+
+function handleClosed() {
+	if (exitMode.value !== 'none') {
+		return;
+	}
+
+	exitMode.value = 'skip';
+	dismissExperiment();
+}
+
+onMounted(() => {
+	modalBus.on('closed', handleClosed);
+});
+
+onBeforeUnmount(() => {
+	modalBus.off('closed', handleClosed);
+});
+</script>
+
+<template>
+	<Modal
+		:name="modalName"
+		width="640px"
+		:event-bus="modalBus"
+		:close-on-click-modal="true"
+		:close-on-press-escape="true"
+		:center="false"
+		:custom-class="$style.modal"
+	>
+		<template #header>
+			<div :class="$style.hero">
+				<div :class="$style.heroBackdrop" aria-hidden="true" />
+				<div :class="$style.heroGraphic">
+					<SurfaceMcpBridgeGraphic size="hero" />
+				</div>
+			</div>
+		</template>
+
+		<template #content>
+			<div :class="$style.content" data-test-id="surface-mcp-intro-content">
+				<N8nText size="xsmall" color="primary" :bold="true" :class="$style.eyebrow">
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.intro.eyebrow') }}
+				</N8nText>
+				<N8nHeading tag="h1" size="xlarge" :bold="true" :class="$style.title">
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.intro.title') }}
+				</N8nHeading>
+				<N8nText tag="p" size="medium" color="text-base" :class="$style.description">
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.intro.description') }}
+					{{ ' ' }}
+					<I18nT
+						keypath="experiments.surfaceMcpToNewCloudUsers.onboarding.intro.settingsHint"
+						tag="span"
+						scope="global"
+					>
+						<template #settingsLink>
+							<N8nLink
+								:to="{ name: MCP_SETTINGS_VIEW }"
+								size="medium"
+								data-test-id="surface-mcp-intro-settings-link"
+							>
+								{{
+									i18n.baseText(
+										'experiments.surfaceMcpToNewCloudUsers.onboarding.intro.settingsLink' as BaseTextKey,
+									)
+								}}
+							</N8nLink>
+						</template>
+					</I18nT>
+				</N8nText>
+			</div>
+		</template>
+
+		<template #footer>
+			<div :class="$style.footer">
+				<N8nButton
+					variant="subtle"
+					data-test-id="surface-mcp-intro-skip-button"
+					@click="handleSkip"
+				>
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.intro.skip') }}
+				</N8nButton>
+				<N8nButton
+					data-test-id="surface-mcp-intro-try-button"
+					:class="$style.tryButton"
+					@click="handleTryIt"
+				>
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.intro.tryIt') }}
+				</N8nButton>
+			</div>
+		</template>
+	</Modal>
+</template>
+
+<style lang="scss" module>
+@use '@n8n/design-system/css/mixins/motion.scss' as motion;
+
+.modal {
+	overflow: hidden;
+
+	:global(.el-dialog__header) {
+		padding: 0;
+		margin: 0;
+	}
+
+	:global(.el-dialog__body) {
+		padding-top: var(--spacing--lg);
+	}
+}
+
+// --- Hero (full-bleed) ----------------------------------------------------
+
+.hero {
+	position: relative;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	width: 100%;
+	min-height: 200px;
+	padding: var(--spacing--xl) var(--spacing--lg);
+	overflow: hidden;
+	border-top-left-radius: inherit;
+	border-top-right-radius: inherit;
+}
+
+.heroBackdrop {
+	position: absolute;
+	inset: 0;
+	background: radial-gradient(
+		60% 80% at 50% 40%,
+		rgb(234 152 75 / 14%) 0%,
+		rgb(234 152 75 / 0%) 100%
+	);
+	pointer-events: none;
+}
+
+.heroGraphic {
+	position: relative;
+
+	@include motion.fade-in-up;
+
+	animation-duration: var(--duration--base);
+}
+
+// --- Copy block -----------------------------------------------------------
+
+.content {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--spacing--3xs);
+	max-width: 60ch;
+	margin: 0 auto;
+	padding-bottom: var(--spacing--xs);
+	text-align: center;
+}
+
+.eyebrow {
+	text-transform: uppercase;
+	letter-spacing: var(--letter-spacing--widest);
+	color: var(--color--orange-700);
+}
+
+.title {
+	letter-spacing: var(--letter-spacing--tight);
+}
+
+.description {
+	margin-top: var(--spacing--3xs);
+	line-height: 1.55;
+}
+
+// --- Footer ---------------------------------------------------------------
+
+.footer {
+	display: flex;
+	justify-content: flex-end;
+	align-items: center;
+	gap: var(--spacing--2xs);
+}
+
+.tryButton {
+	min-width: 132px;
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpTileLogos.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpTileLogos.vue
new file mode 100644
index 00000000000..5f2994e353e
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpTileLogos.vue
@@ -0,0 +1,60 @@
+<template>
+	<div :class="$style.logoRow" data-test-id="mcp-tile-logo-row" aria-hidden="true">
+		<span :class="$style.logoChip">
+			<svg
+				:class="$style.claudeIcon"
+				viewBox="0 0 24 24"
+				fill="none"
+				xmlns="http://www.w3.org/2000/svg"
+				data-test-id="mcp-tile-claude-logo"
+			>
+				<path
+					d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 0 1-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z"
+					fill="#D97757"
+				/>
+			</svg>
+		</span>
+		<span :class="$style.logoChip">
+			<svg
+				:class="$style.openAiIcon"
+				viewBox="0 0 24 24"
+				fill="currentColor"
+				fill-rule="evenodd"
+				xmlns="http://www.w3.org/2000/svg"
+				data-test-id="mcp-tile-openai-logo"
+			>
+				<path
+					d="M9.205 8.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357 1.356-.523 2.117-.523 2.854 0 4.662 2.212 4.662 4.566 0 .167 0 .357-.024.547l-4.71-2.759a.797.797 0 00-.856 0l-5.97 3.473zm10.609 8.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473 1.95-1.118a.433.433 0 01.476 0l4.543 2.617c1.309.76 2.189 2.378 2.189 3.948 0 1.808-1.07 3.473-2.76 4.163zM7.802 12.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545 1.95-4.472 4.591-4.472 1 0 1.927.333 2.712.928L8.23 5.067c-.285.166-.428.404-.428.737v6.898zM12 15.128l-2.795-1.57v-3.33L12 8.658l2.795 1.57v3.33L12 15.128zm1.796 7.23c-1 0-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974 1.142c.167.095.238.238.238.428v5.233c0 2.545-1.974 4.472-4.614 4.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482 4.482 0 014.21 6.327v5.423c0 .333.143.571.428.738l5.947 3.449-1.95 1.118a.432.432 0 01-.476 0zm-.262 3.9c-2.688 0-4.662-2.021-4.662-4.519 0-.19.024-.38.047-.57l4.686 2.71c.286.167.571.167.856 0l5.97-3.448v2.26c0 .19-.07.333-.237.428l-4.543 2.616c-.619.357-1.356.523-2.117.523zm5.899 2.83a5.947 5.947 0 005.827-4.756C22.287 18.339 24 15.84 24 13.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498 0-3.401-2.759-5.947-5.946-5.947-.642 0-1.26.095-1.88.31A5.962 5.962 0 0010.205 0a5.947 5.947 0 00-5.827 4.757C1.713 5.447 0 7.945 0 10.49c0 1.666.713 3.283 1.998 4.448-.119.5-.19 1-.19 1.499 0 3.401 2.759 5.946 5.946 5.946.642 0 1.26-.095 1.88-.309a5.96 5.96 0 004.162 1.713z"
+				/>
+			</svg>
+		</span>
+	</div>
+</template>
+
+<style lang="scss" module>
+.logoRow {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: var(--spacing--2xs);
+}
+
+.logoChip {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 40px;
+	height: 40px;
+	border: 1px solid var(--border-color--subtle);
+	border-radius: var(--radius--lg);
+	background: var(--background--surface);
+	color: var(--icon-color--strong);
+	box-shadow: var(--box-shadow--light);
+}
+
+.claudeIcon,
+.openAiIcon {
+	width: 20px;
+	height: 20px;
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentLogo.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentLogo.vue
new file mode 100644
index 00000000000..f38b3351b02
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentLogo.vue
@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import type { MCPOnboardingClient } from './types';
+
+defineProps<{
+	agent: MCPOnboardingClient;
+}>();
+</script>
+
+<template>
+	<span :class="$style.logo" aria-hidden="true">
+		<svg
+			v-if="agent === 'claude' || agent === 'claude_code'"
+			:class="$style.icon"
+			viewBox="0 0 24 24"
+			fill="none"
+			xmlns="http://www.w3.org/2000/svg"
+		>
+			<path
+				d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z"
+				fill="#D97757"
+			/>
+		</svg>
+		<svg
+			v-else-if="agent === 'codex'"
+			:class="$style.icon"
+			viewBox="0 0 24 24"
+			xmlns="http://www.w3.org/2000/svg"
+		>
+			<path
+				d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z"
+				fill="#fff"
+			/>
+			<path
+				d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z"
+				fill="url(#mcp-onboarding-codex-gradient)"
+			/>
+			<defs>
+				<linearGradient
+					id="mcp-onboarding-codex-gradient"
+					gradientUnits="userSpaceOnUse"
+					x1="12"
+					x2="12"
+					y1="3"
+					y2="21"
+				>
+					<stop stop-color="#B1A7FF" />
+					<stop offset=".5" stop-color="#7A9DFF" />
+					<stop offset="1" stop-color="#3941FF" />
+				</linearGradient>
+			</defs>
+		</svg>
+		<svg
+			v-else-if="agent === 'cursor'"
+			:class="$style.icon"
+			viewBox="0 0 24 24"
+			fill="currentColor"
+			fill-rule="evenodd"
+			xmlns="http://www.w3.org/2000/svg"
+		>
+			<path
+				d="M22.106 5.68L12.5.135a.998.998 0 00-.998 0L1.893 5.68a.84.84 0 00-.419.726v11.186c0 .3.16.577.42.727l9.607 5.547a.999.999 0 00.998 0l9.608-5.547a.84.84 0 00.42-.727V6.407a.84.84 0 00-.42-.726zm-.603 1.176L12.228 22.92c-.063.108-.228.064-.228-.061V12.34a.59.59 0 00-.295-.51l-9.11-5.26c-.107-.062-.063-.228.062-.228h18.55c.264 0 .428.286.296.514z"
+			/>
+		</svg>
+		<svg
+			v-else
+			:class="$style.icon"
+			viewBox="0 0 24 24"
+			fill="currentColor"
+			fill-rule="evenodd"
+			xmlns="http://www.w3.org/2000/svg"
+		>
+			<path
+				d="M9.205 8.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357 1.356-.523 2.117-.523 2.854 0 4.662 2.212 4.662 4.566 0 .167 0 .357-.024.547l-4.71-2.759a.797.797 0 00-.856 0l-5.97 3.473zm10.609 8.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473 1.95-1.118a.433.433 0 01.476 0l4.543 2.617c1.309.76 2.189 2.378 2.189 3.948 0 1.808-1.07 3.473-2.76 4.163zM7.802 12.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545 1.95-4.472 4.591-4.472 1 0 1.927.333 2.712.928L8.23 5.067c-.285.166-.428.404-.428.737v6.898zM12 15.128l-2.795-1.57v-3.33L12 8.658l2.795 1.57v3.33L12 15.128zm1.796 7.23c-1 0-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974 1.142c.167.095.238.238.238.428v5.233c0 2.545-1.974 4.472-4.614 4.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482 4.482 0 014.21 6.327v5.423c0 .333.143.571.428.738l5.947 3.449-1.95 1.118a.432.432 0 01-.476 0zm-.262 3.9c-2.688 0-4.662-2.021-4.662-4.519 0-.19.024-.38.047-.57l4.686 2.71c.286.167.571.167.856 0l5.97-3.448v2.26c0 .19-.07.333-.237.428l-4.543 2.616c-.619.357-1.356.523-2.117.523zm5.899 2.83a5.947 5.947 0 005.827-4.756C22.287 18.339 24 15.84 24 13.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498 0-3.401-2.759-5.947-5.946-5.947-.642 0-1.26.095-1.88.31A5.962 5.962 0 0010.205 0a5.947 5.947 0 00-5.827 4.757C1.713 5.447 0 7.945 0 10.49c0 1.666.713 3.283 1.998 4.448-.119.5-.19 1-.19 1.499 0 3.401 2.759 5.946 5.946 5.946.642 0 1.26-.095 1.88-.309a5.96 5.96 0 004.162 1.713z"
+			/>
+		</svg>
+	</span>
+</template>
+
+<style lang="scss" module>
+.logo {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: var(--mcp-agent-logo-size, 22px);
+	height: var(--mcp-agent-logo-size, 22px);
+	border-radius: var(--radius--sm);
+	background: var(--background--surface);
+	border: 1px solid var(--border-color--subtle);
+	color: var(--icon-color--strong);
+}
+
+.icon {
+	width: var(--mcp-agent-logo-icon-size, 14px);
+	height: var(--mcp-agent-logo-icon-size, 14px);
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentPicker.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentPicker.vue
new file mode 100644
index 00000000000..6072421ba63
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingAgentPicker.vue
@@ -0,0 +1,126 @@
+<script setup lang="ts">
+import MCPOnboardingAgentLogo from './MCPOnboardingAgentLogo.vue';
+import type { MCPOnboardingClient, MCPOnboardingClientOption } from './types';
+
+defineProps<{
+	modelValue: MCPOnboardingClient;
+	options: MCPOnboardingClientOption[];
+}>();
+
+const emit = defineEmits<{
+	'update:modelValue': [value: MCPOnboardingClient];
+}>();
+
+function handleSelect(value: MCPOnboardingClient) {
+	emit('update:modelValue', value);
+}
+</script>
+
+<template>
+	<div :class="$style.picker" data-test-id="mcp-onboarding-client-switcher">
+		<button
+			v-for="option in options"
+			:key="option.value"
+			type="button"
+			:class="[$style.tile, { [$style.tileActive]: modelValue === option.value }]"
+			:aria-pressed="modelValue === option.value"
+			:data-test-id="`mcp-onboarding-agent-option-${option.slug}`"
+			@click="handleSelect(option.value)"
+		>
+			<span :class="$style.tileIconSlot">
+				<MCPOnboardingAgentLogo
+					:agent="option.value"
+					:data-test-id="`mcp-onboarding-agent-logo-${option.slug}`"
+				/>
+			</span>
+			<span :class="$style.tileLabel">{{ option.label }}</span>
+		</button>
+	</div>
+</template>
+
+<style lang="scss" module>
+@use '@n8n/design-system/css/mixins/_focus.scss' as focus;
+
+.picker {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(96px, 1fr));
+	gap: var(--spacing--2xs);
+	width: 100%;
+}
+
+.tile {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	gap: var(--spacing--3xs);
+	min-width: 0;
+	min-height: 76px;
+	padding: var(--spacing--xs) var(--spacing--2xs);
+	border: 1px solid var(--border-color--subtle);
+	border-radius: var(--radius--lg);
+	background: var(--background--surface);
+	color: var(--text-color);
+	font-family: inherit;
+	cursor: pointer;
+	appearance: none;
+	outline-offset: 2px;
+	transition:
+		border-color var(--duration--snappy) var(--easing--ease-out),
+		background-color var(--duration--snappy) var(--easing--ease-out),
+		box-shadow var(--duration--snappy) var(--easing--ease-out),
+		transform var(--duration--snappy) var(--easing--ease-out);
+
+	@include focus.focus-visible-ring;
+
+	&:hover:not(.tileActive) {
+		border-color: var(--border-color--strong);
+		box-shadow: var(--shadow--card-hover);
+		transform: translateY(-1px);
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		transition: none;
+
+		&:hover:not(.tileActive) {
+			transform: none;
+		}
+	}
+}
+
+.tileActive {
+	border-color: var(--color--primary);
+	background: var(--color--orange-alpha-100);
+	box-shadow: inset 0 0 0 1px var(--color--primary);
+
+	&:hover {
+		box-shadow:
+			inset 0 0 0 1px var(--color--primary),
+			var(--shadow--card-hover);
+	}
+
+	.tileLabel {
+		font-weight: var(--font-weight--medium);
+	}
+}
+
+.tileIconSlot {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	--mcp-agent-logo-size: 32px;
+	--mcp-agent-logo-icon-size: 20px;
+}
+
+.tileLabel {
+	display: block;
+	max-width: 100%;
+	font-size: var(--font-size--2xs);
+	font-weight: var(--font-weight--regular);
+	line-height: 1.2;
+	text-align: center;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.test.ts
new file mode 100644
index 00000000000..e7e35c82eda
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.test.ts
@@ -0,0 +1,72 @@
+import { createComponentRenderer } from '@/__tests__/render';
+import userEvent from '@testing-library/user-event';
+import MCPOnboardingClientSetup from './MCPOnboardingClientSetup.vue';
+
+const mockClipboardCopy = vi.fn();
+
+vi.mock('@/app/composables/useClipboard', () => ({
+	useClipboard: () => ({
+		copy: mockClipboardCopy,
+		copied: { value: false },
+		isSupported: { value: true },
+	}),
+}));
+
+const renderComponent = createComponentRenderer(MCPOnboardingClientSetup, {
+	props: {
+		client: 'claude_code',
+		serverUrl: 'https://example.n8n.cloud/mcp-server/http',
+	},
+});
+
+describe('MCPOnboardingClientSetup', () => {
+	beforeEach(() => {
+		mockClipboardCopy.mockReset();
+	});
+
+	it('renders the Claude Code prompt with the server URL and OAuth instructions', () => {
+		const { container } = renderComponent();
+		const text = container.textContent ?? '';
+
+		expect(text).toContain('claude mcp add --scope user --transport http n8n');
+		expect(text).toContain('https://example.n8n.cloud/mcp-server/http');
+		expect(text).toContain('complete the n8n OAuth flow');
+		expect(text).not.toContain('claude mcp list');
+	});
+
+	it('renders the Claude connector prompt', () => {
+		const { container, queryByTestId } = renderComponent({
+			props: { client: 'claude' },
+		});
+		const text = container.textContent ?? '';
+
+		expect(text).toContain('Show me the n8n MCP connector');
+		expect(text).toContain("I'll paste my server URL when you tell me where it goes.");
+		expect(text).not.toContain('claude mcp add --scope user --transport http n8n');
+		expect(queryByTestId('mcp-onboarding-claude-server-url')).not.toBeInTheDocument();
+	});
+
+	it('renders the Codex prompt with the TOML section and home-dir path', () => {
+		const { container } = renderComponent({ props: { client: 'codex' } });
+		const text = container.textContent ?? '';
+
+		expect(text).toContain('[mcp_servers.n8n]');
+		expect(text).toContain('~/.codex/config.toml');
+		expect(text).toContain('https://example.n8n.cloud/mcp-server/http');
+		expect(text).toContain('complete the n8n OAuth flow');
+	});
+
+	it('copies the prompt body and emits copy event on click', async () => {
+		const user = userEvent.setup();
+		const { getByTestId, emitted } = renderComponent();
+
+		await user.click(getByTestId('mcp-onboarding-copy-prompt-button'));
+
+		expect(mockClipboardCopy).toHaveBeenCalledTimes(1);
+		const copiedText = mockClipboardCopy.mock.calls[0][0] as string;
+		expect(copiedText).toContain('claude mcp add --scope user');
+		expect(copiedText).toContain('complete the n8n OAuth flow');
+
+		expect(emitted('copy')).toEqual([['agent-prompt']]);
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.vue
new file mode 100644
index 00000000000..f1eca9fba09
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingClientSetup.vue
@@ -0,0 +1,61 @@
+<script setup lang="ts">
+import { useI18n } from '@n8n/i18n';
+import type { BaseTextKey } from '@n8n/i18n';
+import { computed } from 'vue';
+import MCPOnboardingCopyBlock from './MCPOnboardingCopyBlock.vue';
+import type { MCPOnboardingClient } from './types';
+
+type MCPOnboardingPromptClient = Exclude<MCPOnboardingClient, 'chatgpt'>;
+
+const props = defineProps<{
+	client: MCPOnboardingPromptClient;
+	serverUrl: string;
+}>();
+
+const emit = defineEmits<{
+	copy: [parameter: 'agent-prompt'];
+}>();
+
+const i18n = useI18n();
+
+const promptKeys: Record<MCPOnboardingPromptClient, BaseTextKey> = {
+	claude: 'experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.claude' as BaseTextKey,
+	claude_code: 'experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.claudeCode',
+	cursor: 'experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.cursor' as BaseTextKey,
+	codex: 'experiments.surfaceMcpToNewCloudUsers.onboarding.prompt.codex',
+};
+
+const promptKey = computed(() => promptKeys[props.client]);
+
+const promptBody = computed(() =>
+	i18n.baseText(promptKey.value, {
+		interpolate: {
+			serverUrl: props.serverUrl,
+		},
+	}),
+);
+
+function handlePromptCopy() {
+	emit('copy', 'agent-prompt');
+}
+</script>
+
+<template>
+	<div :class="$style.container" data-test-id="mcp-onboarding-client-setup">
+		<MCPOnboardingCopyBlock
+			:content="promptBody"
+			:copy-tooltip="i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.copy.tooltip')"
+			copy-button-test-id="mcp-onboarding-copy-prompt-button"
+			@copy="handlePromptCopy"
+		/>
+	</div>
+</template>
+
+<style lang="scss" module>
+.container {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing--2xs);
+	width: 100%;
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingCopyBlock.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingCopyBlock.vue
new file mode 100644
index 00000000000..5fa4cf56d79
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingCopyBlock.vue
@@ -0,0 +1,105 @@
+<script setup lang="ts">
+import { useClipboard } from '@/app/composables/useClipboard';
+import { N8nIconButton, N8nMarkdown, N8nTooltip } from '@n8n/design-system';
+import { useI18n } from '@n8n/i18n';
+import { computed, ref } from 'vue';
+
+const props = withDefaults(
+	defineProps<{
+		content: string;
+		copyTooltip?: string;
+		copyButtonTestId?: string;
+	}>(),
+	{
+		copyTooltip: undefined,
+		copyButtonTestId: undefined,
+	},
+);
+
+const emit = defineEmits<{
+	copy: [value: string];
+}>();
+
+const i18n = useI18n();
+const { copy } = useClipboard();
+
+const justCopied = ref(false);
+let copyResetTimeout: ReturnType<typeof setTimeout> | null = null;
+
+const markdown = computed(() => `\`\`\`\n${props.content}\n\`\`\``);
+const copyTooltip = computed(() =>
+	justCopied.value
+		? i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.copy.copied')
+		: (props.copyTooltip ?? i18n.baseText('generic.copy')),
+);
+
+async function handleCopy() {
+	await copy(props.content);
+	emit('copy', props.content);
+
+	justCopied.value = true;
+	if (copyResetTimeout) {
+		clearTimeout(copyResetTimeout);
+	}
+	copyResetTimeout = setTimeout(() => {
+		justCopied.value = false;
+	}, 1800);
+}
+</script>
+
+<template>
+	<div :class="$style.codeBlock">
+		<div :class="$style.codeToolbar">
+			<N8nTooltip :content="copyTooltip" placement="top">
+				<N8nIconButton
+					icon="copy"
+					variant="ghost"
+					size="small"
+					:aria-label="copyTooltip"
+					:data-test-id="copyButtonTestId"
+					@click="handleCopy"
+				/>
+			</N8nTooltip>
+		</div>
+		<N8nMarkdown :content="markdown" />
+	</div>
+</template>
+
+<style lang="scss" module>
+.codeBlock {
+	position: relative;
+	border: var(--border);
+	border-radius: var(--radius);
+	background: var(--background--surface);
+	overflow: hidden;
+	width: 100%;
+
+	:global(.n8n-markdown) {
+		width: 100%;
+	}
+
+	:global(pre) {
+		margin: 0;
+		max-height: 240px;
+		overflow-y: auto;
+	}
+
+	:global(code) {
+		display: block;
+		overflow-x: auto;
+		font-size: var(--font-size--3xs);
+		line-height: 1.55;
+		padding-right: var(--spacing--xl);
+	}
+}
+
+.codeToolbar {
+	position: absolute;
+	top: var(--spacing--4xs);
+	right: var(--spacing--4xs);
+	z-index: 1;
+	background: var(--background--surface);
+	border-radius: var(--radius--xs);
+	padding: var(--spacing--5xs);
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.test.ts
new file mode 100644
index 00000000000..52b115290c9
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.test.ts
@@ -0,0 +1,366 @@
+import { createComponentRenderer } from '@/__tests__/render';
+import { SURFACE_MCP_ONBOARDING_MODAL_KEY } from '@/experiments/surfaceMcpToNewCloudUsers/constants';
+import userEvent from '@testing-library/user-event';
+import { waitFor } from '@testing-library/vue';
+import { defineComponent, reactive } from 'vue';
+import MCPOnboardingModal from './MCPOnboardingModal.vue';
+
+const mockClipboardCopy = vi.fn();
+const mockShowError = vi.fn();
+
+vi.mock('@/app/composables/useClipboard', () => ({
+	useClipboard: () => ({
+		copy: mockClipboardCopy,
+		copied: { value: false },
+		isSupported: { value: true },
+	}),
+}));
+
+vi.mock('@/app/composables/useToast', () => ({
+	useToast: () => ({
+		showError: mockShowError,
+	}),
+}));
+
+vi.mock('@n8n/stores/useRootStore', () => ({
+	useRootStore: () => ({
+		urlBaseEditor: 'https://example.n8n.cloud/',
+	}),
+}));
+
+const mockExperimentStore = {
+	trackEnableClicked: vi.fn(),
+	trackEnabled: vi.fn(),
+	trackEnableFailed: vi.fn(),
+	trackDismissed: vi.fn(),
+	trackClientSelected: vi.fn(),
+	trackSetupShown: vi.fn(),
+	trackCopiedParameter: vi.fn(),
+	dismissFirstOpenModal: vi.fn(),
+};
+
+vi.mock('@/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store', () => ({
+	useSurfaceMcpToNewCloudUsersStore: () => mockExperimentStore,
+}));
+
+type MockMcpStore = {
+	mcpAccessEnabled: boolean;
+	mcpManagedByEnv: boolean;
+	setMcpAccessEnabled: ReturnType<typeof vi.fn>;
+};
+
+let mockMcpStore: MockMcpStore;
+
+vi.mock('@/features/ai/mcpAccess/mcp.store', () => ({
+	useMCPStore: () => mockMcpStore,
+}));
+
+const ModalStub = defineComponent({
+	props: ['name', 'eventBus'],
+	template: `
+		<div :data-test-id="name">
+			<slot name="content" />
+			<slot name="footer" />
+			<button data-test-id="mcp-onboarding-generic-close" @click="eventBus.emit('closed')" />
+		</div>
+	`,
+});
+
+const renderComponent = createComponentRenderer(MCPOnboardingModal, {
+	props: {
+		data: {
+			surface: 'first_open_modal',
+		},
+	},
+	global: {
+		stubs: {
+			Modal: ModalStub,
+			// Stub ElSwitch to avoid jsdom-triggered spurious model updates.
+			ElSwitch: {
+				props: ['modelValue', 'disabled', 'loading'],
+				template:
+					'<button type="button" role="switch" :data-test-id="$attrs[\'data-test-id\']" :aria-checked="!!modelValue" :disabled="disabled || loading" @click="$emit(\'update:modelValue\')" />',
+			},
+		},
+	},
+});
+
+describe('MCPOnboardingModal', () => {
+	beforeEach(() => {
+		mockClipboardCopy.mockReset();
+		mockShowError.mockReset();
+		vi.clearAllMocks();
+
+		mockMcpStore = reactive({
+			mcpAccessEnabled: false,
+			mcpManagedByEnv: false,
+			setMcpAccessEnabled: vi.fn().mockImplementation(async () => {
+				mockMcpStore.mcpAccessEnabled = true;
+				return true;
+			}),
+		}) as MockMcpStore;
+	});
+
+	it('enables MCP, loads the prompt, and tracks enable telemetry when toggled on', async () => {
+		const user = userEvent.setup();
+		const { getByRole, findByText, getByTestId } = renderComponent();
+
+		expect(getByTestId(SURFACE_MCP_ONBOARDING_MODAL_KEY)).toBeInTheDocument();
+		await user.click(getByRole('switch'));
+
+		expect(mockMcpStore.setMcpAccessEnabled).toHaveBeenCalledWith(true);
+		expect(mockExperimentStore.trackEnableClicked).toHaveBeenCalledWith('first_open_modal');
+		expect(await findByText(/Show me the n8n MCP connector/)).toBeInTheDocument();
+		expect(mockExperimentStore.trackEnabled).toHaveBeenCalledWith('first_open_modal');
+	});
+
+	it('hides the prompt when toggled off', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+		mockMcpStore.setMcpAccessEnabled = vi.fn().mockImplementation(async () => {
+			mockMcpStore.mcpAccessEnabled = false;
+			return false;
+		});
+
+		const { getByRole, findByText, queryByTestId } = renderComponent();
+
+		await findByText(/Show me the n8n MCP connector/);
+		await user.click(getByRole('switch'));
+
+		expect(mockMcpStore.setMcpAccessEnabled).toHaveBeenCalledWith(false);
+		expect(queryByTestId('mcp-onboarding-client-setup')).not.toBeInTheDocument();
+		expect(mockExperimentStore.trackEnableClicked).not.toHaveBeenCalled();
+		expect(mockExperimentStore.trackEnabled).not.toHaveBeenCalled();
+	});
+
+	it('disables the toggle when MCP is managed by the environment', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpManagedByEnv = true;
+
+		const { getByRole } = renderComponent();
+
+		const toggle = getByRole('switch');
+		expect(toggle).toBeDisabled();
+
+		await user.click(toggle);
+
+		expect(mockMcpStore.setMcpAccessEnabled).not.toHaveBeenCalled();
+	});
+
+	it('renders the prompt immediately when MCP is already enabled on mount', async () => {
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { findByTestId, findByText, getByTestId } = renderComponent();
+
+		expect(await findByText(/Show me the n8n MCP connector/)).toBeInTheDocument();
+		expect(await findByText('https://example.n8n.cloud/mcp-server/http')).toBeInTheDocument();
+		expect(await findByText('Paste the prompt in Claude')).toBeInTheDocument();
+		expect(await findByText('Paste Server URL')).toBeInTheDocument();
+		expect(await findByTestId('mcp-onboarding-claude-server-url')).toBeInTheDocument();
+		expect(getByTestId('mcp-onboarding-copy-server-url-button')).toBeEnabled();
+		expect(mockExperimentStore.trackSetupShown).toHaveBeenCalledWith(
+			'first_open_modal',
+			'claude',
+			'prompt',
+		);
+	});
+
+	it('copies the Claude server URL with server-url telemetry', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByTestId } = renderComponent();
+
+		await user.click(getByTestId('mcp-onboarding-copy-server-url-button'));
+
+		expect(mockClipboardCopy).toHaveBeenCalledWith('https://example.n8n.cloud/mcp-server/http');
+		expect(mockExperimentStore.trackCopiedParameter).toHaveBeenCalledWith(
+			'first_open_modal',
+			'claude',
+			'server-url',
+		);
+	});
+
+	it('preserves the resolved prompt if disabling MCP fails', async () => {
+		const user = userEvent.setup();
+		const error = new Error('disable failed');
+		mockMcpStore.mcpAccessEnabled = true;
+		mockMcpStore.setMcpAccessEnabled = vi.fn().mockRejectedValue(error);
+
+		const { getByRole, findByText, getByTestId } = renderComponent();
+
+		await findByText(/Show me the n8n MCP connector/);
+		await user.click(getByRole('switch'));
+
+		await waitFor(() => {
+			expect(mockShowError).toHaveBeenCalledWith(error, 'Error updating MCP access');
+		});
+		expect(await findByText(/Show me the n8n MCP connector/)).toBeInTheDocument();
+		expect(getByTestId('mcp-onboarding-copy-prompt-button')).toBeEnabled();
+	});
+
+	it('switches to Claude Code setup instructions', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, getByTestId, container } = renderComponent();
+
+		await user.click(getByText('Claude Code'));
+
+		expect(mockExperimentStore.trackClientSelected).toHaveBeenCalledWith(
+			'first_open_modal',
+			'claude_code',
+		);
+		expect(mockExperimentStore.trackSetupShown).toHaveBeenCalledWith(
+			'first_open_modal',
+			'claude_code',
+			'prompt',
+		);
+		expect(container.textContent).toContain('claude mcp add --scope user --transport http n8n');
+		expect(getByTestId('mcp-onboarding-restart-step')).toHaveTextContent(
+			'Restart Claude Code and connect to n8n',
+		);
+	});
+
+	it('switches between Claude Code and Codex setup instructions', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, getByTestId, queryByTestId, container } = renderComponent();
+
+		await user.click(getByText('Codex'));
+
+		expect(mockExperimentStore.trackClientSelected).toHaveBeenCalledWith(
+			'first_open_modal',
+			'codex',
+		);
+		expect(container.textContent).toContain('Paste the prompt in Codex');
+		expect(container.textContent).toContain('[mcp_servers.n8n]');
+		expect(queryByTestId('mcp-onboarding-claude-server-url')).not.toBeInTheDocument();
+		expect(getByTestId('mcp-onboarding-restart-step')).toHaveTextContent(
+			'Restart Codex and connect to n8n',
+		);
+	});
+
+	it('switches to Claude setup instructions', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, queryByTestId, container } = renderComponent();
+
+		await user.click(getByText('Claude'));
+
+		expect(mockExperimentStore.trackClientSelected).not.toHaveBeenCalled();
+		expect(container.textContent).toContain('Show me the n8n MCP connector');
+		expect(container.textContent).toContain('Paste the prompt in Claude');
+		expect(container.textContent).toContain('Paste Server URL');
+		expect(container.textContent).not.toContain('claude mcp add --scope user --transport http n8n');
+		expect(queryByTestId('mcp-onboarding-restart-step')).not.toBeInTheDocument();
+	});
+
+	it('switches to ChatGPT setup instructions', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, getByTestId, queryByTestId, container } = renderComponent();
+
+		await user.click(getByText('ChatGPT'));
+
+		expect(mockExperimentStore.trackClientSelected).toHaveBeenCalledWith(
+			'first_open_modal',
+			'chatgpt',
+		);
+		expect(mockExperimentStore.trackSetupShown).toHaveBeenCalledWith(
+			'first_open_modal',
+			'chatgpt',
+			'chatgpt_custom_app',
+		);
+		expect(getByTestId('mcp-onboarding-chatgpt-developer-mode-step')).toBeInTheDocument();
+		expect(getByTestId('mcp-onboarding-chatgpt-custom-app-step')).toBeInTheDocument();
+		expect(container.textContent).toContain('Enable developer mode in ChatGPT');
+		expect(container.textContent).toContain('Turn on developer mode.');
+		expect(container.textContent).toContain('App name');
+		expect(container.textContent).toContain('n8n');
+		expect(container.textContent).toContain('https://example.n8n.cloud/mcp-server/http');
+		expect(container.textContent).not.toContain('After you turn it on');
+		expect(container.textContent).not.toContain('Click Create, then use these values:');
+		expect(container.textContent).not.toContain('Description');
+		expect(container.textContent).not.toContain(
+			'Connect ChatGPT to this n8n instance through MCP.',
+		);
+		expect(container.textContent).not.toContain('complete the n8n OAuth flow');
+		expect(container.textContent).not.toContain('[mcp_servers.n8n]');
+		expect(queryByTestId('mcp-onboarding-client-setup')).not.toBeInTheDocument();
+		expect(queryByTestId('mcp-onboarding-claude-server-url')).not.toBeInTheDocument();
+		expect(queryByTestId('mcp-onboarding-copy-prompt-button')).not.toBeInTheDocument();
+		expect(queryByTestId('mcp-onboarding-restart-step')).not.toBeInTheDocument();
+
+		await user.click(getByTestId('mcp-onboarding-copy-chatgpt-server-url-button'));
+
+		expect(mockClipboardCopy).toHaveBeenCalledWith('https://example.n8n.cloud/mcp-server/http');
+		expect(mockExperimentStore.trackCopiedParameter).toHaveBeenCalledWith(
+			'first_open_modal',
+			'chatgpt',
+			'server-url',
+		);
+
+		await user.click(getByTestId('mcp-onboarding-copy-chatgpt-app-name-button'));
+
+		expect(mockClipboardCopy).toHaveBeenCalledWith('n8n');
+		expect(mockExperimentStore.trackCopiedParameter).toHaveBeenCalledWith(
+			'first_open_modal',
+			'chatgpt',
+			'chatgpt-app-name',
+		);
+	});
+
+	it('switches to Cursor setup instructions', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, getByTestId, container } = renderComponent();
+
+		await user.click(getByText('Cursor'));
+
+		expect(mockExperimentStore.trackClientSelected).toHaveBeenCalledWith(
+			'first_open_modal',
+			'cursor',
+		);
+		expect(container.textContent).toContain('~/.cursor/mcp.json');
+		expect(container.textContent).toContain('complete the n8n OAuth flow');
+		expect(container.textContent).not.toContain('Authorization');
+		expect(getByTestId('mcp-onboarding-restart-step')).toHaveTextContent(
+			'Restart Cursor and connect to n8n',
+		);
+	});
+
+	it('forwards prompt copy telemetry with the selected client', async () => {
+		const user = userEvent.setup();
+		mockMcpStore.mcpAccessEnabled = true;
+
+		const { getByText, getByTestId } = renderComponent();
+
+		await user.click(getByText('Cursor'));
+		await user.click(getByTestId('mcp-onboarding-copy-prompt-button'));
+
+		expect(mockExperimentStore.trackCopiedParameter).toHaveBeenCalledWith(
+			'first_open_modal',
+			'cursor',
+			'agent-prompt',
+		);
+	});
+
+	it('tracks tile modal close as a dismissal when MCP remains disabled', async () => {
+		const user = userEvent.setup();
+		const { getByTestId } = renderComponent({ props: { data: { surface: 'tile' } } });
+
+		await user.click(getByTestId('mcp-onboarding-generic-close'));
+
+		expect(mockExperimentStore.trackDismissed).toHaveBeenCalledWith('tile', {
+			activeClient: 'claude',
+			enabledDuringThisOpen: false,
+			mcpAccessEnabled: false,
+		});
+		expect(mockExperimentStore.dismissFirstOpenModal).not.toHaveBeenCalled();
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.vue b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.vue
new file mode 100644
index 00000000000..6e3a1d89cd6
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/MCPOnboardingModal.vue
@@ -0,0 +1,677 @@
+<script setup lang="ts">
+import Modal from '@/app/components/Modal.vue';
+import { useToast } from '@/app/composables/useToast';
+import SurfaceMcpBridgeGraphic from '@/experiments/surfaceMcpToNewCloudUsers/components/SurfaceMcpBridgeGraphic.vue';
+import { SURFACE_MCP_ONBOARDING_MODAL_KEY } from '@/experiments/surfaceMcpToNewCloudUsers/constants';
+import { useSurfaceMcpToNewCloudUsersStore } from '@/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store';
+import MCPAccessToggle from '@/features/ai/mcpAccess/components/header/McpAccessToggle.vue';
+import { MCP_ENDPOINT, MCP_SETTINGS_VIEW } from '@/features/ai/mcpAccess/mcp.constants';
+import { useMCPStore } from '@/features/ai/mcpAccess/mcp.store';
+import { N8nIcon, N8nLink, N8nText } from '@n8n/design-system';
+import { useI18n } from '@n8n/i18n';
+import type { BaseTextKey } from '@n8n/i18n';
+import { useRootStore } from '@n8n/stores/useRootStore';
+import { createEventBus } from '@n8n/utils/event-bus';
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
+import { I18nT } from 'vue-i18n';
+import MCPOnboardingAgentPicker from './MCPOnboardingAgentPicker.vue';
+import MCPOnboardingClientSetup from './MCPOnboardingClientSetup.vue';
+import MCPOnboardingCopyBlock from './MCPOnboardingCopyBlock.vue';
+import type { MCPOnboardingClient, MCPOnboardingClientOption } from './types';
+
+type MCPOnboardingSurface = 'tile' | 'first_open_modal';
+type MCPOnboardingPromptClient = Exclude<MCPOnboardingClient, 'chatgpt'>;
+type MCPOnboardingCopiedParameter = 'agent-prompt' | 'server-url' | 'chatgpt-app-name';
+type MCPOnboardingSetupType = 'prompt' | 'chatgpt_custom_app';
+
+const MCP_ONBOARDING_DOCS_URL = 'https://docs.n8n.io/advanced-ai/mcp/accessing-n8n-mcp-server/';
+
+const props = defineProps<{
+	data?: {
+		surface?: MCPOnboardingSurface;
+	};
+}>();
+
+const i18n = useI18n();
+const toast = useToast();
+const rootStore = useRootStore();
+const mcpStore = useMCPStore();
+const experimentStore = useSurfaceMcpToNewCloudUsersStore();
+const modalBus = createEventBus();
+
+const activeClient = ref<MCPOnboardingClient>('claude');
+const isToggling = ref(false);
+const enabledDuringThisOpen = ref(false);
+const setupShownClients = new Set<MCPOnboardingClient>();
+
+const surface = computed<MCPOnboardingSurface>(() => props.data?.surface ?? 'tile');
+
+const clientOptions = computed<MCPOnboardingClientOption[]>(() => [
+	{
+		value: 'claude',
+		slug: 'claude',
+		label: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.client.claude' as BaseTextKey,
+		),
+	},
+	{
+		value: 'claude_code',
+		slug: 'claude-code',
+		label: i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.client.claudeCode'),
+	},
+	{
+		value: 'codex',
+		slug: 'codex',
+		label: i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.client.codex'),
+	},
+	{
+		value: 'cursor',
+		slug: 'cursor',
+		label: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.client.cursor' as BaseTextKey,
+		),
+	},
+	{
+		value: 'chatgpt',
+		slug: 'chatgpt',
+		label: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.client.chatgpt' as BaseTextKey,
+		),
+	},
+]);
+
+const serverUrl = computed(() => `${rootStore.urlBaseEditor}${MCP_ENDPOINT}`);
+const isChatGptClient = computed(() => activeClient.value === 'chatgpt');
+const showServerUrlStep = computed(() => activeClient.value === 'claude');
+const showRestartStep = computed(
+	() =>
+		activeClient.value === 'claude_code' ||
+		activeClient.value === 'cursor' ||
+		activeClient.value === 'codex',
+);
+const activePromptClient = computed<MCPOnboardingPromptClient>(() =>
+	activeClient.value === 'chatgpt' ? 'claude' : activeClient.value,
+);
+const activeClientLabel = computed(
+	() =>
+		clientOptions.value.find((option) => option.value === activeClient.value)?.label ??
+		activeClient.value,
+);
+const promptSectionTitle = computed(() =>
+	i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.section.prompt.title', {
+		interpolate: { assistant: activeClientLabel.value },
+	}),
+);
+const restartSectionTitle = computed(() =>
+	i18n.baseText(
+		'experiments.surfaceMcpToNewCloudUsers.onboarding.section.restart.title' as BaseTextKey,
+		{
+			interpolate: { assistant: activeClientLabel.value },
+		},
+	),
+);
+const chatGptCustomAppFields = computed(() => [
+	{
+		label: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.appName.label' as BaseTextKey,
+		),
+		content: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.appName.value' as BaseTextKey,
+		),
+		parameter: 'chatgpt-app-name' as const,
+		testId: 'mcp-onboarding-chatgpt-app-name',
+		copyButtonTestId: 'mcp-onboarding-copy-chatgpt-app-name-button',
+	},
+	{
+		label: i18n.baseText(
+			'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.serverUrl.label' as BaseTextKey,
+		),
+		content: serverUrl.value,
+		parameter: 'server-url' as const,
+		testId: 'mcp-onboarding-chatgpt-server-url',
+		copyButtonTestId: 'mcp-onboarding-copy-chatgpt-server-url-button',
+	},
+]);
+
+function getSetupType(client: MCPOnboardingClient): MCPOnboardingSetupType {
+	return client === 'chatgpt' ? 'chatgpt_custom_app' : 'prompt';
+}
+
+function trackCurrentSetupShown() {
+	if (!mcpStore.mcpAccessEnabled || setupShownClients.has(activeClient.value)) {
+		return;
+	}
+
+	setupShownClients.add(activeClient.value);
+	experimentStore.trackSetupShown(
+		surface.value,
+		activeClient.value,
+		getSetupType(activeClient.value),
+	);
+}
+
+async function handleToggleMcpAccess() {
+	const nextValue = !mcpStore.mcpAccessEnabled;
+
+	try {
+		isToggling.value = true;
+
+		if (nextValue) {
+			experimentStore.trackEnableClicked(surface.value);
+			const updated = await mcpStore.setMcpAccessEnabled(true);
+
+			if (!updated) {
+				return;
+			}
+
+			enabledDuringThisOpen.value = true;
+			experimentStore.trackEnabled(surface.value);
+			trackCurrentSetupShown();
+			return;
+		}
+
+		await mcpStore.setMcpAccessEnabled(false);
+	} catch (error) {
+		if (nextValue) {
+			experimentStore.trackEnableFailed(
+				surface.value,
+				error instanceof Error ? error.constructor.name : 'unknown',
+			);
+		}
+		toast.showError(error, i18n.baseText('settings.mcp.toggle.error'));
+	} finally {
+		isToggling.value = false;
+	}
+}
+
+function handleModalClosed() {
+	if (!enabledDuringThisOpen.value && !mcpStore.mcpAccessEnabled) {
+		if (surface.value === 'first_open_modal') {
+			experimentStore.dismissFirstOpenModal();
+		}
+
+		experimentStore.trackDismissed(surface.value, {
+			activeClient: activeClient.value,
+			enabledDuringThisOpen: enabledDuringThisOpen.value,
+			mcpAccessEnabled: mcpStore.mcpAccessEnabled,
+		});
+	}
+}
+
+function handleClientChange(value: MCPOnboardingClient) {
+	if (activeClient.value === value) {
+		return;
+	}
+
+	activeClient.value = value;
+	experimentStore.trackClientSelected(surface.value, activeClient.value);
+	trackCurrentSetupShown();
+}
+
+function handleCopyParameter(parameter: MCPOnboardingCopiedParameter) {
+	experimentStore.trackCopiedParameter(surface.value, activeClient.value, parameter);
+}
+
+onMounted(() => {
+	modalBus.on('closed', handleModalClosed);
+	trackCurrentSetupShown();
+});
+
+onBeforeUnmount(() => {
+	modalBus.off('closed', handleModalClosed);
+});
+</script>
+
+<template>
+	<Modal
+		:name="SURFACE_MCP_ONBOARDING_MODAL_KEY"
+		:title="i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.title')"
+		width="640px"
+		:event-bus="modalBus"
+		:close-on-click-modal="true"
+		:custom-class="$style.modal"
+	>
+		<template #header>
+			<div :class="$style.header">
+				<div :class="$style.headerGraphic">
+					<SurfaceMcpBridgeGraphic size="hero" />
+				</div>
+				<h1 :class="$style.headerTitle">
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.title') }}
+				</h1>
+				<N8nText
+					tag="p"
+					size="small"
+					color="text-base"
+					align="center"
+					:class="$style.headerDescription"
+				>
+					{{ i18n.baseText('experiments.surfaceMcpToNewCloudUsers.onboarding.description') }}
+				</N8nText>
+			</div>
+		</template>
+
+		<template #content>
+			<div :class="$style.content" data-test-id="mcp-onboarding-modal-content">
+				<!-- Step 1: Enable MCP access -->
+				<section :class="$style.section">
+					<header :class="[$style.sectionHeader, $style.accessHeader]">
+						<div :class="$style.accessTitleRow">
+							<span
+								:class="[
+									$style.sectionStep,
+									{ [$style.sectionStepDone]: mcpStore.mcpAccessEnabled },
+								]"
+							>
+								<N8nIcon
+									v-if="mcpStore.mcpAccessEnabled"
+									icon="check"
+									size="xsmall"
+									:stroke-width="2.5"
+								/>
+								<template v-else>1</template>
+							</span>
+							<h2 :class="$style.sectionTitle">
+								{{
+									i18n.baseText(
+										'experiments.surfaceMcpToNewCloudUsers.onboarding.section.access.title',
+									)
+								}}
+							</h2>
+						</div>
+						<MCPAccessToggle
+							:model-value="mcpStore.mcpAccessEnabled"
+							:disabled="mcpStore.mcpManagedByEnv"
+							:loading="isToggling"
+							:managed-by-env="mcpStore.mcpManagedByEnv"
+							@disable-mcp-access="handleToggleMcpAccess"
+						/>
+					</header>
+				</section>
+
+				<!-- Steps 2 & 3 reveal once MCP is enabled -->
+				<template v-if="mcpStore.mcpAccessEnabled">
+					<!-- Step 2: Choose your agent -->
+					<section :class="[$style.section, $style.revealSection]">
+						<header :class="$style.sectionHeader">
+							<span :class="$style.sectionStep">2</span>
+							<h2 :class="$style.sectionTitle">
+								{{
+									i18n.baseText(
+										'experiments.surfaceMcpToNewCloudUsers.onboarding.section.client.title',
+									)
+								}}
+							</h2>
+						</header>
+						<div :class="$style.sectionBody">
+							<MCPOnboardingAgentPicker
+								:model-value="activeClient"
+								:options="clientOptions"
+								@update:model-value="handleClientChange"
+							/>
+						</div>
+					</section>
+
+					<template v-if="isChatGptClient">
+						<!-- Step 3: Enable developer mode -->
+						<section
+							:class="[$style.section, $style.revealSection]"
+							data-test-id="mcp-onboarding-chatgpt-developer-mode-step"
+						>
+							<header :class="$style.sectionHeader">
+								<span :class="$style.sectionStep">3</span>
+								<h2 :class="$style.sectionTitle">
+									{{
+										i18n.baseText(
+											'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptDeveloperMode.title' as BaseTextKey,
+										)
+									}}
+								</h2>
+							</header>
+							<div :class="$style.sectionBody">
+								<N8nText tag="p" size="small" color="text-base" :class="$style.stepDescription">
+									{{
+										i18n.baseText(
+											'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptDeveloperMode.description' as BaseTextKey,
+										)
+									}}
+								</N8nText>
+							</div>
+						</section>
+
+						<!-- Step 4: Create a custom app -->
+						<section
+							:class="[$style.section, $style.revealSection]"
+							data-test-id="mcp-onboarding-chatgpt-custom-app-step"
+						>
+							<header :class="$style.sectionHeader">
+								<span :class="$style.sectionStep">4</span>
+								<h2 :class="$style.sectionTitle">
+									{{
+										i18n.baseText(
+											'experiments.surfaceMcpToNewCloudUsers.onboarding.section.chatgptCustomApp.title' as BaseTextKey,
+										)
+									}}
+								</h2>
+							</header>
+							<div :class="$style.sectionBody">
+								<div :class="$style.copyFields">
+									<div
+										v-for="field in chatGptCustomAppFields"
+										:key="field.testId"
+										:class="$style.copyField"
+									>
+										<N8nText tag="p" size="small" color="text-light" :class="$style.copyFieldLabel">
+											{{ field.label }}
+										</N8nText>
+										<MCPOnboardingCopyBlock
+											:content="field.content"
+											:copy-button-test-id="field.copyButtonTestId"
+											:data-test-id="field.testId"
+											@copy="handleCopyParameter(field.parameter)"
+										/>
+									</div>
+								</div>
+							</div>
+						</section>
+					</template>
+
+					<template v-else>
+						<!-- Step 3: Paste the prompt -->
+						<section :class="[$style.section, $style.revealSection]">
+							<header :class="$style.sectionHeader">
+								<span :class="$style.sectionStep">3</span>
+								<h2 :class="$style.sectionTitle">
+									{{ promptSectionTitle }}
+								</h2>
+							</header>
+							<div :class="$style.sectionBody">
+								<MCPOnboardingClientSetup
+									:client="activePromptClient"
+									:server-url="serverUrl"
+									@copy="handleCopyParameter"
+								/>
+							</div>
+						</section>
+
+						<section v-if="showServerUrlStep" :class="[$style.section, $style.revealSection]">
+							<header :class="$style.sectionHeader">
+								<span :class="$style.sectionStep">4</span>
+								<h2 :class="$style.sectionTitle">
+									{{
+										i18n.baseText(
+											'experiments.surfaceMcpToNewCloudUsers.onboarding.section.serverUrl.title' as BaseTextKey,
+										)
+									}}
+								</h2>
+							</header>
+							<div :class="$style.sectionBody">
+								<MCPOnboardingCopyBlock
+									:content="serverUrl"
+									copy-button-test-id="mcp-onboarding-copy-server-url-button"
+									data-test-id="mcp-onboarding-claude-server-url"
+									@copy="handleCopyParameter('server-url')"
+								/>
+							</div>
+						</section>
+
+						<section
+							v-if="showRestartStep"
+							:class="[$style.section, $style.revealSection]"
+							data-test-id="mcp-onboarding-restart-step"
+						>
+							<header :class="$style.sectionHeader">
+								<span :class="$style.sectionStep">4</span>
+								<h2 :class="$style.sectionTitle">
+									{{ restartSectionTitle }}
+								</h2>
+							</header>
+						</section>
+					</template>
+				</template>
+			</div>
+		</template>
+
+		<template #footer>
+			<N8nText
+				tag="p"
+				size="xsmall"
+				color="text-light"
+				align="center"
+				:class="$style.footer"
+				data-test-id="mcp-onboarding-footer"
+			>
+				<I18nT
+					keypath="experiments.surfaceMcpToNewCloudUsers.onboarding.footer"
+					tag="span"
+					scope="global"
+				>
+					<template #settingsLink>
+						<N8nLink
+							:to="{ name: MCP_SETTINGS_VIEW }"
+							size="xsmall"
+							data-test-id="mcp-onboarding-settings-link"
+						>
+							{{
+								i18n.baseText(
+									'experiments.surfaceMcpToNewCloudUsers.onboarding.intro.settingsLink' as BaseTextKey,
+								)
+							}}
+						</N8nLink>
+					</template>
+					<template #docsLink>
+						<N8nLink
+							:href="MCP_ONBOARDING_DOCS_URL"
+							target="_blank"
+							rel="noopener noreferrer"
+							size="xsmall"
+							data-test-id="mcp-onboarding-docs-link"
+						>
+							{{
+								i18n.baseText(
+									'experiments.surfaceMcpToNewCloudUsers.onboarding.footer.docsLink' as BaseTextKey,
+								)
+							}}
+						</N8nLink>
+					</template>
+				</I18nT>
+			</N8nText>
+		</template>
+	</Modal>
+</template>
+
+<style lang="scss" module>
+@use '@n8n/design-system/css/mixins/motion.scss' as motion;
+
+.modal {
+	overflow: hidden;
+
+	:global(.el-dialog__header) {
+		padding: 0;
+		margin: 0;
+	}
+
+	:global(.el-dialog__body) {
+		padding-top: var(--spacing--lg);
+		padding-bottom: var(--spacing--sm);
+
+		> :last-child {
+			margin-top: var(--spacing--sm);
+		}
+	}
+}
+
+// --- Header (centered hero) -----------------------------------------------
+
+.header {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--spacing--3xs);
+	padding: var(--spacing--xl) var(--spacing--3xl) var(--spacing--lg);
+	background: linear-gradient(180deg, rgb(234 152 75 / 8%) 0%, rgb(234 152 75 / 0%) 100%);
+	border-bottom: 1px solid var(--border-color--subtle);
+	text-align: center;
+}
+
+.headerGraphic {
+	margin-bottom: var(--spacing--xs);
+
+	@include motion.fade-in-up;
+}
+
+.headerTitle {
+	margin: 0;
+	font-size: var(--font-size--xl);
+	font-weight: var(--font-weight--bold);
+	letter-spacing: var(--letter-spacing--tight);
+	color: var(--text-color);
+}
+
+.headerDescription {
+	max-width: 50ch;
+	line-height: 1.55;
+	margin-top: var(--spacing--3xs);
+}
+
+// --- Sections -------------------------------------------------------------
+
+.content {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing--lg);
+}
+
+.section {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing--2xs);
+}
+
+.revealSection {
+	@include motion.fade-in-up;
+
+	animation-duration: var(--duration--base);
+	animation-fill-mode: both;
+
+	&:nth-of-type(2) {
+		animation-delay: 60ms;
+	}
+
+	&:nth-of-type(3) {
+		animation-delay: 120ms;
+	}
+}
+
+.sectionHeader {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing--2xs);
+}
+
+.sectionStep {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 22px;
+	height: 22px;
+	border-radius: var(--radius--full);
+	background: var(--background--surface);
+	border: 1px solid var(--border-color--strong);
+	color: var(--text-color--subtle);
+	font-size: var(--font-size--3xs);
+	font-weight: var(--font-weight--bold);
+	line-height: 1;
+	flex-shrink: 0;
+	transition:
+		background-color var(--duration--snappy) ease,
+		border-color var(--duration--snappy) ease,
+		color var(--duration--snappy) ease;
+}
+
+.sectionStepDone {
+	background: var(--color--green-500, #22c55e);
+	border-color: var(--color--green-500, #22c55e);
+	color: var(--color--neutral-white, #fff);
+}
+
+.sectionTitle {
+	margin: 0;
+	font-size: var(--font-size--sm);
+	font-weight: var(--font-weight--bold);
+	letter-spacing: var(--letter-spacing--tight);
+	color: var(--text-color);
+}
+
+.sectionBody {
+	display: flex;
+	flex-direction: column;
+	align-items: flex-start;
+	gap: var(--spacing--xs);
+	padding-left: calc(22px + var(--spacing--2xs));
+}
+
+.stepDescription,
+.stepHelper {
+	margin: 0;
+	line-height: 1.5;
+}
+
+.copyFields {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing--xs);
+	width: 100%;
+}
+
+.copyField {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing--4xs);
+	width: 100%;
+}
+
+.copyFieldLabel {
+	margin: 0;
+	font-weight: var(--font-weight--medium);
+}
+
+// --- Section 2: access toggle row -----------------------------------------
+
+.accessHeader {
+	justify-content: space-between;
+	gap: var(--spacing--md);
+	width: 100%;
+
+	@media (max-width: 600px) {
+		align-items: flex-start;
+		flex-direction: column;
+	}
+}
+
+.accessTitleRow {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--spacing--2xs);
+}
+
+.accessRow {
+	flex-direction: row;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--spacing--md);
+	width: 100%;
+
+	@media (max-width: 600px) {
+		flex-direction: column;
+		align-items: flex-start;
+	}
+}
+
+.footer {
+	margin: 0;
+	padding: 0 var(--spacing--md);
+	color: var(--text-color--subtler);
+	line-height: 1.35;
+}
+</style>
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/types.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/types.ts
new file mode 100644
index 00000000000..4d543659f2f
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/components/onboarding/types.ts
@@ -0,0 +1,7 @@
+export type MCPOnboardingClient = 'claude' | 'claude_code' | 'codex' | 'cursor' | 'chatgpt';
+
+export type MCPOnboardingClientOption = {
+	value: MCPOnboardingClient;
+	slug: string;
+	label: string;
+};
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.test.ts
new file mode 100644
index 00000000000..ee133aa92b9
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.test.ts
@@ -0,0 +1,162 @@
+import { effectScope, ref, type EffectScope } from 'vue';
+import { useSurfaceMcpEmptyState } from './useSurfaceMcpEmptyState';
+
+const mocks = vi.hoisted(() => ({
+	isEligible: { value: true },
+	mcpAccessEnabled: false,
+	isEnabled: false,
+	isTileVariant: false,
+	isFirstOpenModalVariant: false,
+	hasDismissedFirstOpenModal: false,
+	trackEntryPointViewed: vi.fn(),
+	trackOpportunityViewed: vi.fn(),
+}));
+
+vi.mock('@/features/ai/mcpAccess/mcp.store', () => ({
+	useMCPStore: () => ({
+		get mcpAccessEnabled() {
+			return mocks.mcpAccessEnabled;
+		},
+	}),
+}));
+
+vi.mock('../stores/surfaceMcpToNewCloudUsers.store', () => ({
+	useSurfaceMcpToNewCloudUsersStore: () => ({
+		get isEnabled() {
+			return mocks.isEnabled;
+		},
+		get isTileVariant() {
+			return mocks.isTileVariant;
+		},
+		get isFirstOpenModalVariant() {
+			return mocks.isFirstOpenModalVariant;
+		},
+		get hasDismissedFirstOpenModal() {
+			return mocks.hasDismissedFirstOpenModal;
+		},
+		trackEntryPointViewed: mocks.trackEntryPointViewed,
+		trackOpportunityViewed: mocks.trackOpportunityViewed,
+	}),
+}));
+
+vi.mock('./useSurfaceMcpToNewCloudUsersEligibility', () => ({
+	useSurfaceMcpToNewCloudUsersEligibility: () => ({
+		isEligible: mocks.isEligible,
+	}),
+}));
+
+function renderComposable({
+	canCreateWorkflow = true,
+	showAppSelection = false,
+	showBuilderPrompt = false,
+	showRecommendedTemplatesInline = false,
+}: Partial<{
+	canCreateWorkflow: boolean;
+	showAppSelection: boolean;
+	showBuilderPrompt: boolean;
+	showRecommendedTemplatesInline: boolean;
+}> = {}) {
+	const scope = effectScope();
+	const result = scope.run(() =>
+		useSurfaceMcpEmptyState({
+			canCreateWorkflow: ref(canCreateWorkflow),
+			showAppSelection: ref(showAppSelection),
+			showBuilderPrompt: ref(showBuilderPrompt),
+			showRecommendedTemplatesInline: ref(showRecommendedTemplatesInline),
+		}),
+	);
+
+	if (!result) {
+		throw new Error('Failed to render useSurfaceMcpEmptyState');
+	}
+
+	return { result, scope };
+}
+
+describe('useSurfaceMcpEmptyState', () => {
+	let scope: EffectScope | undefined;
+
+	beforeEach(() => {
+		mocks.isEligible.value = true;
+		mocks.mcpAccessEnabled = false;
+		mocks.isEnabled = false;
+		mocks.isTileVariant = false;
+		mocks.isFirstOpenModalVariant = false;
+		mocks.hasDismissedFirstOpenModal = false;
+		mocks.trackEntryPointViewed.mockClear();
+		mocks.trackOpportunityViewed.mockClear();
+	});
+
+	afterEach(() => {
+		scope?.stop();
+		scope = undefined;
+	});
+
+	it('tracks an eligible control opportunity without showing the tile', () => {
+		mocks.isEnabled = true;
+		mocks.isTileVariant = false;
+
+		const rendered = renderComposable();
+		scope = rendered.scope;
+
+		expect(rendered.result.showOpportunity.value).toBe(true);
+		expect(rendered.result.showTile.value).toBe(false);
+		expect(rendered.result.suppressedBy.value).toBeNull();
+		expect(mocks.trackOpportunityViewed).toHaveBeenCalledWith(
+			'tile',
+			'empty_state_tile',
+			false,
+			null,
+			false,
+		);
+		expect(mocks.trackEntryPointViewed).not.toHaveBeenCalled();
+	});
+
+	it('tracks no-create suppression without showing the tile entry point', () => {
+		mocks.isEnabled = true;
+		mocks.isTileVariant = true;
+
+		const rendered = renderComposable({ canCreateWorkflow: false });
+		scope = rendered.scope;
+
+		expect(rendered.result.showTile.value).toBe(false);
+		expect(rendered.result.suppressedBy.value).toBe('no_create_permission');
+		expect(mocks.trackOpportunityViewed).toHaveBeenCalledWith(
+			'tile',
+			'empty_state_tile',
+			false,
+			'no_create_permission',
+			false,
+		);
+		expect(mocks.trackEntryPointViewed).not.toHaveBeenCalled();
+	});
+
+	it('shows and tracks the tile for tile variants', () => {
+		mocks.isEnabled = true;
+		mocks.isTileVariant = true;
+
+		const rendered = renderComposable();
+		scope = rendered.scope;
+
+		expect(rendered.result.showTile.value).toBe(true);
+		expect(rendered.result.suppressedBy.value).toBeNull();
+		expect(mocks.trackOpportunityViewed).toHaveBeenCalledWith(
+			'tile',
+			'empty_state_tile',
+			true,
+			null,
+			false,
+		);
+		expect(mocks.trackEntryPointViewed).toHaveBeenCalledWith('tile', 'empty_state_tile', false);
+	});
+
+	it('shows the reminder after the retained first-open modal was dismissed', () => {
+		mocks.isFirstOpenModalVariant = true;
+		mocks.hasDismissedFirstOpenModal = true;
+
+		const rendered = renderComposable();
+		scope = rendered.scope;
+
+		expect(rendered.result.showReminder.value).toBe(true);
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.ts
new file mode 100644
index 00000000000..7b5ae241836
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpEmptyState.ts
@@ -0,0 +1,108 @@
+import { useMCPStore } from '@/features/ai/mcpAccess/mcp.store';
+import { computed, ref, watch, type Ref } from 'vue';
+import { useSurfaceMcpToNewCloudUsersStore } from '../stores/surfaceMcpToNewCloudUsers.store';
+import { useSurfaceMcpToNewCloudUsersEligibility } from './useSurfaceMcpToNewCloudUsersEligibility';
+
+type SurfaceMcpEmptyStateSuppression =
+	| 'app_selection'
+	| 'builder_prompt'
+	| 'recommended_templates'
+	| 'no_create_permission';
+
+type BooleanRef = Readonly<Ref<boolean>>;
+
+type UseSurfaceMcpEmptyStateOptions = {
+	canCreateWorkflow: BooleanRef;
+	showAppSelection: BooleanRef;
+	showBuilderPrompt: BooleanRef;
+	showRecommendedTemplatesInline: BooleanRef;
+};
+
+export function useSurfaceMcpEmptyState({
+	canCreateWorkflow,
+	showAppSelection,
+	showBuilderPrompt,
+	showRecommendedTemplatesInline,
+}: UseSurfaceMcpEmptyStateOptions) {
+	const mcpStore = useMCPStore();
+	const surfaceMcpStore = useSurfaceMcpToNewCloudUsersStore();
+	const { isEligible } = useSurfaceMcpToNewCloudUsersEligibility();
+	const hasTrackedEntryPointViewed = ref(false);
+	const hasTrackedOpportunityViewed = ref(false);
+
+	const showOpportunity = computed(() => isEligible.value && surfaceMcpStore.isEnabled);
+
+	const suppressedBy = computed<SurfaceMcpEmptyStateSuppression | null>(() => {
+		if (!showOpportunity.value) {
+			return null;
+		}
+
+		if (!canCreateWorkflow.value) {
+			return 'no_create_permission';
+		}
+
+		if (showAppSelection.value) {
+			return 'app_selection';
+		}
+
+		if (showBuilderPrompt.value) {
+			return 'builder_prompt';
+		}
+
+		if (showRecommendedTemplatesInline.value) {
+			return 'recommended_templates';
+		}
+
+		return null;
+	});
+
+	const showTile = computed(
+		() => showOpportunity.value && surfaceMcpStore.isTileVariant && suppressedBy.value === null,
+	);
+
+	const showReminder = computed(
+		() =>
+			isEligible.value &&
+			surfaceMcpStore.isFirstOpenModalVariant &&
+			surfaceMcpStore.hasDismissedFirstOpenModal,
+	);
+
+	watch(
+		showOpportunity,
+		(value) => {
+			if (value && !hasTrackedOpportunityViewed.value) {
+				hasTrackedOpportunityViewed.value = true;
+				surfaceMcpStore.trackOpportunityViewed(
+					'tile',
+					'empty_state_tile',
+					showTile.value,
+					suppressedBy.value,
+					mcpStore.mcpAccessEnabled,
+				);
+			}
+		},
+		{ immediate: true },
+	);
+
+	watch(
+		showTile,
+		(value, previousValue) => {
+			if (value && !previousValue && !hasTrackedEntryPointViewed.value) {
+				hasTrackedEntryPointViewed.value = true;
+				surfaceMcpStore.trackEntryPointViewed(
+					'tile',
+					'empty_state_tile',
+					mcpStore.mcpAccessEnabled,
+				);
+			}
+		},
+		{ immediate: true },
+	);
+
+	return {
+		showOpportunity,
+		suppressedBy,
+		showTile,
+		showReminder,
+	};
+}
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.test.ts
new file mode 100644
index 00000000000..5ba7c21629c
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.test.ts
@@ -0,0 +1,91 @@
+const mockIsTrulyEmpty = vi.fn();
+
+let mockIsCloudDeployment = false;
+let mockUserIsTrialing = false;
+let mockIsAdminOrOwner = false;
+
+vi.mock('@/app/stores/settings.store', () => ({
+	useSettingsStore: () => ({
+		get isCloudDeployment() {
+			return mockIsCloudDeployment;
+		},
+	}),
+}));
+
+vi.mock('@/app/stores/cloudPlan.store', () => ({
+	useCloudPlanStore: () => ({
+		get userIsTrialing() {
+			return mockUserIsTrialing;
+		},
+	}),
+}));
+
+vi.mock('@/features/settings/users/users.store', () => ({
+	useUsersStore: () => ({
+		get isAdminOrOwner() {
+			return mockIsAdminOrOwner;
+		},
+	}),
+}));
+
+vi.mock('@/features/workflows/readyToRun/composables/useEmptyStateDetection', () => ({
+	useEmptyStateDetection: () => ({
+		isTrulyEmpty: mockIsTrulyEmpty,
+	}),
+}));
+
+import { useSurfaceMcpToNewCloudUsersEligibility } from './useSurfaceMcpToNewCloudUsersEligibility';
+
+describe('useSurfaceMcpToNewCloudUsersEligibility', () => {
+	beforeEach(() => {
+		mockIsCloudDeployment = false;
+		mockUserIsTrialing = false;
+		mockIsAdminOrOwner = false;
+		mockIsTrulyEmpty.mockReset();
+		mockIsTrulyEmpty.mockReturnValue(false);
+	});
+
+	it('returns eligible when all local gate conditions pass', () => {
+		mockIsCloudDeployment = true;
+		mockUserIsTrialing = true;
+		mockIsAdminOrOwner = true;
+		mockIsTrulyEmpty.mockReturnValue(true);
+
+		const { isEligible } = useSurfaceMcpToNewCloudUsersEligibility();
+
+		expect(isEligible.value).toBe(true);
+	});
+
+	it('returns ineligible for non-admin users', () => {
+		mockIsCloudDeployment = true;
+		mockUserIsTrialing = true;
+		mockIsAdminOrOwner = false;
+		mockIsTrulyEmpty.mockReturnValue(true);
+
+		const { isEligible } = useSurfaceMcpToNewCloudUsersEligibility();
+
+		expect(isEligible.value).toBe(false);
+	});
+
+	it('returns ineligible outside cloud deployments', () => {
+		mockIsCloudDeployment = false;
+		mockUserIsTrialing = true;
+		mockIsAdminOrOwner = true;
+		mockIsTrulyEmpty.mockReturnValue(true);
+
+		const { isEligible } = useSurfaceMcpToNewCloudUsersEligibility();
+
+		expect(isEligible.value).toBe(false);
+	});
+
+	it('returns ineligible for non-trial users', () => {
+		mockIsCloudDeployment = true;
+		mockUserIsTrialing = false;
+		mockIsAdminOrOwner = true;
+		mockIsTrulyEmpty.mockReturnValue(true);
+
+		const { isEligible } = useSurfaceMcpToNewCloudUsersEligibility();
+
+		expect(isEligible.value).toBe(false);
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.ts
new file mode 100644
index 00000000000..4704e6e76f8
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/composables/useSurfaceMcpToNewCloudUsersEligibility.ts
@@ -0,0 +1,24 @@
+import { useCloudPlanStore } from '@/app/stores/cloudPlan.store';
+import { useSettingsStore } from '@/app/stores/settings.store';
+import { useUsersStore } from '@/features/settings/users/users.store';
+import { useEmptyStateDetection } from '@/features/workflows/readyToRun/composables/useEmptyStateDetection';
+import { computed } from 'vue';
+
+export function useSurfaceMcpToNewCloudUsersEligibility() {
+	const usersStore = useUsersStore();
+	const { isTrulyEmpty } = useEmptyStateDetection();
+	const settingsStore = useSettingsStore();
+	const cloudPlanStore = useCloudPlanStore();
+
+	const isEligible = computed(
+		() =>
+			settingsStore.isCloudDeployment &&
+			cloudPlanStore.userIsTrialing &&
+			usersStore.isAdminOrOwner &&
+			isTrulyEmpty(),
+	);
+
+	return {
+		isEligible,
+	};
+}
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/constants.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/constants.ts
new file mode 100644
index 00000000000..a1d975516df
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/constants.ts
@@ -0,0 +1,2 @@
+export const SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY = 'surfaceMcpFirstOpenIntroModal';
+export const SURFACE_MCP_ONBOARDING_MODAL_KEY = 'mcpOnboardingModal';
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/modals.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/modals.ts
new file mode 100644
index 00000000000..a614f86443a
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/modals.ts
@@ -0,0 +1,23 @@
+import type { ModalDefinition } from '@/app/moduleInitializer/module.types';
+import {
+	SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY,
+	SURFACE_MCP_ONBOARDING_MODAL_KEY,
+} from './constants';
+
+export const SURFACE_MCP_TO_NEW_CLOUD_USERS_MODALS: ModalDefinition[] = [
+	{
+		key: SURFACE_MCP_ONBOARDING_MODAL_KEY,
+		component: async () => await import('./components/onboarding/MCPOnboardingModal.vue'),
+		initialState: {
+			open: false,
+			data: {
+				surface: 'tile',
+			},
+		},
+	},
+	{
+		key: SURFACE_MCP_FIRST_OPEN_INTRO_MODAL_KEY,
+		component: async () => await import('./components/SurfaceMcpFirstOpenIntroModal.vue'),
+		initialState: { open: false },
+	},
+];
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.test.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.test.ts
new file mode 100644
index 00000000000..4cb3d5c302d
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.test.ts
@@ -0,0 +1,153 @@
+import { SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT } from '@/app/constants/experiments';
+import { STORES } from '@n8n/stores';
+import { createPinia, setActivePinia } from 'pinia';
+import { ref } from 'vue';
+
+const mockTrack = vi.fn();
+
+vi.mock('@/app/composables/useTelemetry', () => ({
+	useTelemetry: () => ({
+		track: mockTrack,
+	}),
+}));
+
+const firstOpenSeenStorage = ref<string | null>(null);
+const firstOpenDismissedStorage = ref<string | null>(null);
+
+vi.mock('@/app/composables/useStorage', () => ({
+	useStorage: (key: string) => {
+		if (key === 'N8N_SURFACE_MCP_TO_NEW_CLOUD_USERS_FIRST_OPEN_SEEN') {
+			return firstOpenSeenStorage;
+		}
+
+		if (key === 'N8N_SURFACE_MCP_TO_NEW_CLOUD_USERS_FIRST_OPEN_DISMISSED') {
+			return firstOpenDismissedStorage;
+		}
+
+		throw new Error(`Unexpected storage key: ${key}`);
+	},
+}));
+
+const mockGetVariant = vi.fn();
+
+vi.mock('@/app/stores/posthog.store', () => ({
+	usePostHog: () => ({
+		getVariant: mockGetVariant,
+	}),
+}));
+
+import { useSurfaceMcpToNewCloudUsersStore } from './surfaceMcpToNewCloudUsers.store';
+
+type CopiedParameter = Parameters<
+	ReturnType<typeof useSurfaceMcpToNewCloudUsersStore>['trackCopiedParameter']
+>[2];
+
+describe('surfaceMcpToNewCloudUsers store', () => {
+	let store: ReturnType<typeof useSurfaceMcpToNewCloudUsersStore>;
+
+	beforeEach(() => {
+		setActivePinia(createPinia());
+		mockTrack.mockClear();
+		mockGetVariant.mockReset();
+		firstOpenSeenStorage.value = null;
+		firstOpenDismissedStorage.value = null;
+
+		store = useSurfaceMcpToNewCloudUsersStore();
+	});
+
+	it.each([
+		SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1,
+		SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2,
+	])('derives tile entry state from PostHog variant %s', (variant) => {
+		mockGetVariant.mockReturnValue(variant);
+
+		expect(store.$id).toBe(STORES.EXPERIMENT_SURFACE_MCP_TO_NEW_CLOUD_USERS);
+		expect(store.currentVariant).toBe(variant);
+		expect(store.isEnabled).toBe(true);
+		expect(store.isTileVariant).toBe(true);
+		expect(store.isFirstOpenModalVariant).toBe(false);
+	});
+
+	it('treats the control variant as experiment enrollment', () => {
+		mockGetVariant.mockReturnValue(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.control);
+
+		expect(store.currentVariant).toBe(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.control);
+		expect(store.isEnabled).toBe(true);
+		expect(store.isTileVariant).toBe(false);
+		expect(store.isFirstOpenModalVariant).toBe(false);
+	});
+
+	it('persists the first eligible open marker for the retained intro modal', () => {
+		store.markFirstEligibleOpenSeen();
+
+		expect(firstOpenSeenStorage.value).toBe('true');
+		expect(store.hasSeenFirstEligibleOpen).toBe(true);
+	});
+
+	it('persists first-open modal dismissal for the retained intro modal', () => {
+		store.dismissFirstOpenModal();
+
+		expect(firstOpenDismissedStorage.value).toBe('true');
+		expect(store.hasDismissedFirstOpenModal).toBe(true);
+		expect(firstOpenSeenStorage.value).toBe('true');
+		expect(store.hasSeenFirstEligibleOpen).toBe(true);
+	});
+
+	it('tracks copied parameter payload with the current variant', () => {
+		mockGetVariant.mockReturnValue(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1);
+		expectTypeOf<CopiedParameter>().toEqualTypeOf<
+			'agent-prompt' | 'server-url' | 'chatgpt-app-name'
+		>();
+
+		store.trackCopiedParameter('tile', 'chatgpt', 'server-url');
+
+		expect(mockTrack).toHaveBeenCalledWith('MCP onboarding copied parameter', {
+			surface: 'tile',
+			client: 'chatgpt',
+			parameter: 'server-url',
+			variant: SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1,
+		});
+	});
+
+	it('tracks entry point views with the current variant', () => {
+		mockGetVariant.mockReturnValue(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2);
+
+		store.trackEntryPointViewed('tile', 'empty_state_tile', false);
+
+		expect(mockTrack).toHaveBeenCalledWith('MCP onboarding entry point viewed', {
+			surface: 'tile',
+			entry_point: 'empty_state_tile',
+			mcp_access_enabled: false,
+			variant: SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2,
+		});
+	});
+
+	it('tracks eligible empty-state opportunities with the current variant', () => {
+		mockGetVariant.mockReturnValue(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.control);
+
+		store.trackOpportunityViewed('tile', 'empty_state_tile', false, null, false);
+
+		expect(mockTrack).toHaveBeenCalledWith('MCP onboarding opportunity viewed', {
+			surface: 'tile',
+			entry_point: 'empty_state_tile',
+			eligible: true,
+			surface_available: false,
+			suppressed_by: null,
+			mcp_access_enabled: false,
+			variant: SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.control,
+		});
+	});
+
+	it('tracks setup visibility with the current variant', () => {
+		mockGetVariant.mockReturnValue(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2);
+
+		store.trackSetupShown('tile', 'chatgpt', 'chatgpt_custom_app');
+
+		expect(mockTrack).toHaveBeenCalledWith('MCP onboarding setup shown', {
+			surface: 'tile',
+			client: 'chatgpt',
+			setup_type: 'chatgpt_custom_app',
+			variant: SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2,
+		});
+	});
+});
diff --git a/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.ts b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.ts
new file mode 100644
index 00000000000..b32eccca8a9
--- /dev/null
+++ b/packages/frontend/editor-ui/src/experiments/surfaceMcpToNewCloudUsers/stores/surfaceMcpToNewCloudUsers.store.ts
@@ -0,0 +1,208 @@
+import { useStorage } from '@/app/composables/useStorage';
+import { useTelemetry } from '@/app/composables/useTelemetry';
+import { SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT } from '@/app/constants/experiments';
+import { usePostHog } from '@/app/stores/posthog.store';
+import { STORES } from '@n8n/stores';
+import { defineStore } from 'pinia';
+import { computed } from 'vue';
+import type { MCPOnboardingClient as SurfaceMcpOnboardingClient } from '../components/onboarding/types';
+
+const FIRST_OPEN_SEEN_STORAGE_KEY = 'N8N_SURFACE_MCP_TO_NEW_CLOUD_USERS_FIRST_OPEN_SEEN';
+const FIRST_OPEN_DISMISSED_STORAGE_KEY = 'N8N_SURFACE_MCP_TO_NEW_CLOUD_USERS_FIRST_OPEN_DISMISSED';
+
+type SurfaceMcpOnboardingSurface = 'tile' | 'first_open_modal';
+type SurfaceMcpOnboardingEntryPoint = 'empty_state_tile';
+type SurfaceMcpOnboardingParameter = 'agent-prompt' | 'server-url' | 'chatgpt-app-name';
+type SurfaceMcpOnboardingSetupType = 'prompt' | 'chatgpt_custom_app';
+type SurfaceMcpOnboardingSuppression =
+	| 'app_selection'
+	| 'builder_prompt'
+	| 'recommended_templates'
+	| 'no_create_permission';
+
+export const useSurfaceMcpToNewCloudUsersStore = defineStore(
+	STORES.EXPERIMENT_SURFACE_MCP_TO_NEW_CLOUD_USERS,
+	() => {
+		const posthogStore = usePostHog();
+		const telemetry = useTelemetry();
+		const firstOpenSeenStorage = useStorage(FIRST_OPEN_SEEN_STORAGE_KEY);
+		const firstOpenDismissedStorage = useStorage(FIRST_OPEN_DISMISSED_STORAGE_KEY);
+
+		const currentVariant = computed(() =>
+			posthogStore.getVariant(SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.name),
+		);
+
+		const isTileVariant = computed(() => {
+			const variant = currentVariant.value;
+
+			return (
+				variant === SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant1 ||
+				variant === SURFACE_MCP_TO_NEW_CLOUD_USERS_EXPERIMENT.variant2
+			);
+		});
+		const isFirstOpenModalVariant = computed(() => false);
+		const isEnabled = computed(() => Boolean(currentVariant.value));
+
+		const hasSeenFirstEligibleOpen = computed(() => firstOpenSeenStorage.value === 'true');
+		const hasDismissedFirstOpenModal = computed(() => firstOpenDismissedStorage.value === 'true');
+
+		const getTelemetryPayload = (payload: Record<string, unknown> = {}) => ({
+			...payload,
+			variant: currentVariant.value,
+		});
+
+		function markFirstEligibleOpenSeen() {
+			firstOpenSeenStorage.value = 'true';
+		}
+
+		function dismissFirstOpenModal() {
+			markFirstEligibleOpenSeen();
+			firstOpenDismissedStorage.value = 'true';
+		}
+
+		function trackEntryPointViewed(
+			surface: SurfaceMcpOnboardingSurface,
+			entryPoint: SurfaceMcpOnboardingEntryPoint,
+			mcpAccessEnabled: boolean,
+		) {
+			telemetry.track(
+				'MCP onboarding entry point viewed',
+				getTelemetryPayload({
+					surface,
+					entry_point: entryPoint,
+					mcp_access_enabled: mcpAccessEnabled,
+				}),
+			);
+		}
+
+		function trackOpportunityViewed(
+			surface: SurfaceMcpOnboardingSurface,
+			entryPoint: SurfaceMcpOnboardingEntryPoint,
+			surfaceAvailable: boolean,
+			suppressedBy: SurfaceMcpOnboardingSuppression | null,
+			mcpAccessEnabled: boolean,
+		) {
+			telemetry.track(
+				'MCP onboarding opportunity viewed',
+				getTelemetryPayload({
+					surface,
+					entry_point: entryPoint,
+					eligible: true,
+					surface_available: surfaceAvailable,
+					suppressed_by: suppressedBy,
+					mcp_access_enabled: mcpAccessEnabled,
+				}),
+			);
+		}
+
+		function trackOpened(
+			surface: SurfaceMcpOnboardingSurface,
+			payload: { entryPoint?: SurfaceMcpOnboardingEntryPoint; mcpAccessEnabled?: boolean } = {},
+		) {
+			telemetry.track(
+				'MCP onboarding opened',
+				getTelemetryPayload({
+					surface,
+					...(payload.entryPoint ? { entry_point: payload.entryPoint } : {}),
+					...(payload.mcpAccessEnabled !== undefined
+						? { mcp_access_enabled: payload.mcpAccessEnabled }
+						: {}),
+				}),
+			);
+		}
+
+		function trackDismissed(
+			surface: SurfaceMcpOnboardingSurface,
+			payload: {
+				activeClient?: SurfaceMcpOnboardingClient;
+				enabledDuringThisOpen?: boolean;
+				mcpAccessEnabled?: boolean;
+			} = {},
+		) {
+			telemetry.track(
+				'MCP onboarding dismissed',
+				getTelemetryPayload({
+					surface,
+					...(payload.activeClient ? { active_client: payload.activeClient } : {}),
+					...(payload.enabledDuringThisOpen !== undefined
+						? { enabled_during_this_open: payload.enabledDuringThisOpen }
+						: {}),
+					...(payload.mcpAccessEnabled !== undefined
+						? { mcp_access_enabled: payload.mcpAccessEnabled }
+						: {}),
+				}),
+			);
+		}
+
+		function trackEnableClicked(surface: SurfaceMcpOnboardingSurface) {
+			telemetry.track('MCP onboarding enable clicked', getTelemetryPayload({ surface }));
+		}
+
+		function trackEnabled(surface: SurfaceMcpOnboardingSurface) {
+			telemetry.track('MCP onboarding enabled', getTelemetryPayload({ surface }));
+		}
+
+		function trackEnableFailed(surface: SurfaceMcpOnboardingSurface, errorType: string) {
+			telemetry.track(
+				'MCP onboarding enable failed',
+				getTelemetryPayload({ surface, error_type: errorType }),
+			);
+		}
+
+		function trackClientSelected(
+			surface: SurfaceMcpOnboardingSurface,
+			client: SurfaceMcpOnboardingClient,
+		) {
+			telemetry.track('MCP onboarding client selected', getTelemetryPayload({ surface, client }));
+		}
+
+		function trackSetupShown(
+			surface: SurfaceMcpOnboardingSurface,
+			client: SurfaceMcpOnboardingClient,
+			setupType: SurfaceMcpOnboardingSetupType,
+		) {
+			telemetry.track(
+				'MCP onboarding setup shown',
+				getTelemetryPayload({ surface, client, setup_type: setupType }),
+			);
+		}
+
+		function trackCopiedParameter(
+			surface: SurfaceMcpOnboardingSurface,
+			client: SurfaceMcpOnboardingClient,
+			parameter: SurfaceMcpOnboardingParameter,
+		) {
+			telemetry.track(
+				'MCP onboarding copied parameter',
+				getTelemetryPayload({ surface, client, parameter }),
+			);
+		}
+
+		function reset() {
+			firstOpenSeenStorage.value = null;
+			firstOpenDismissedStorage.value = null;
+		}
+
+		return {
+			currentVariant,
+			isEnabled,
+			isTileVariant,
+			isFirstOpenModalVariant,
+			hasSeenFirstEligibleOpen,
+			hasDismissedFirstOpenModal,
+			markFirstEligibleOpenSeen,
+			dismissFirstOpenModal,
+			trackEntryPointViewed,
+			trackOpportunityViewed,
+			trackOpened,
+			trackDismissed,
+			trackEnableClicked,
+			trackEnabled,
+			trackEnableFailed,
+			trackClientSelected,
+			trackSetupShown,
+			trackCopiedParameter,
+			reset,
+		};
+	},
+);
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiThreadView.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiThreadView.vue
index a3c98af4282..613b1534f4a 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiThreadView.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiThreadView.vue
@@ -17,18 +17,23 @@ import {
 	N8nResizeWrapper,
 	N8nScrollArea,
 	N8nText,
+	N8nTooltip,
+	TOOLTIP_DELAY_MS,
 } from '@n8n/design-system';
-import { useElementSize, useScroll } from '@vueuse/core';
+import { useElementSize, useScroll, useSessionStorage, useWindowSize } from '@vueuse/core';
 import { useI18n } from '@n8n/i18n';
 import type { InstanceAiAttachment } from '@n8n/api-types';
 import { useRootStore } from '@n8n/stores/useRootStore';
 import { usePageRedirectionHelper } from '@/app/composables/usePageRedirectionHelper';
+import { COLLAPSED_MAIN_SIDEBAR_WIDTH, useSidebarLayout } from '@/app/composables/useSidebarLayout';
 import { provideThread, useInstanceAiStore } from './instanceAi.store';
 import { useCanvasPreview } from './useCanvasPreview';
 import { useEventRelay } from './useEventRelay';
 import { useExecutionPushEvents } from './useExecutionPushEvents';
 import { useCreditWarningBanner } from './composables/useCreditWarningBanner';
+import { useTransitionGate } from './useTransitionGate';
 import { INSTANCE_AI_VIEW, NEW_CONVERSATION_TITLE } from './constants';
+import { useSidebarState } from './instanceAiLayout';
 import InstanceAiMessage from './components/InstanceAiMessage.vue';
 import InstanceAiInput from './components/InstanceAiInput.vue';
 import InstanceAiDebugPanel from './components/InstanceAiDebugPanel.vue';
@@ -56,6 +61,9 @@ const i18n = useI18n();
 const router = useRouter();
 const { goToUpgrade } = usePageRedirectionHelper();
 const creditBanner = useCreditWarningBanner(isLowCredits);
+const sidebar = useSidebarState();
+const { width: windowWidth } = useWindowSize();
+const { isCollapsed: isMainSidebarCollapsed, sidebarWidth: mainSidebarWidth } = useSidebarLayout();
 
 // Running builders render in a dedicated bottom section of the conversation.
 // Once a builder finishes it falls out of this list and AgentTimeline renders
@@ -76,7 +84,7 @@ const executionTracking = useExecutionPushEvents();
 // the "New conversation" → real title flash when resuming a recent thread.
 const currentThreadTitle = computed<string | undefined>(() => {
 	const threadSummary = store.threads.find((t) => t.id === props.threadId);
-	if (threadSummary && threadSummary.title && threadSummary.title !== NEW_CONVERSATION_TITLE) {
+	if (threadSummary?.title && threadSummary.title !== NEW_CONVERSATION_TITLE) {
 		return threadSummary.title;
 	}
 	const firstUserMsg = thread.messages.find((m) => m.role === 'user');
@@ -97,18 +105,139 @@ provide('openWorkflowPreview', preview.openWorkflowPreview);
 provide('openDataTablePreview', preview.openDataTablePreview);
 
 // --- Side panels ---
-const showArtifactsPanel = ref(true);
 const showDebugPanel = ref(false);
 const isDebugEnabled = computed(() => localStorage.getItem('instanceAi.debugMode') === 'true');
+const hasPreviewTabs = computed(() => preview.allArtifactTabs.value.length > 0);
+const isArtifactsPanelPinned = useSessionStorage('instanceAi.artifactsPanelPinned', true);
+const isArtifactsPanelRevealed = ref(false);
+const DEFAULT_INSTANCE_AI_SIDEBAR_WIDTH = 260;
+const MIN_AVAILABLE_WIDTH_FOR_PINNED_ARTIFACTS_PANEL = 900;
+const artifactsPanelTransitionGate = useTransitionGate({
+	isBlocked: () => thread.isHydratingThread,
+});
+const previewPanelTransitionGate = useTransitionGate({
+	isBlocked: () => thread.isHydratingThread,
+});
+const isArtifactsPanelTransitionEnabled = artifactsPanelTransitionGate.isEnabled;
+const isPreviewPanelTransitionEnabled = previewPanelTransitionGate.isEnabled;
+const isPreviewPanelTransitioning = ref(false);
+const artifactsPreviewToggleLabel = computed(() =>
+	i18n.baseText(
+		preview.isPreviewVisible.value
+			? 'instanceAi.artifactsPanel.hidePreview'
+			: 'instanceAi.artifactsPanel.showPreview',
+	),
+);
+const artifactsPanelTransitionName = computed(() =>
+	isPreviewPanelTransitioning.value ? 'artifacts-panel-preview' : 'artifacts-panel-fade',
+);
+
+function toggleArtifactsPreview() {
+	if (preview.isPreviewVisible.value) {
+		preview.closePreview();
+		return;
+	}
+
+	const firstTab = preview.allArtifactTabs.value[0];
+	if (firstTab) {
+		preview.selectTab(firstTab.id);
+	}
+}
+
+function revealArtifactsPanel() {
+	if (
+		!canShowArtifactsPanel.value ||
+		isArtifactsPanelEffectivelyPinned.value ||
+		preview.isPreviewVisible.value
+	) {
+		return;
+	}
+	isArtifactsPanelRevealed.value = true;
+}
+
+function hideArtifactsPanel(event?: FocusEvent) {
+	if (isArtifactsPanelEffectivelyPinned.value) return;
+	if (
+		event?.currentTarget instanceof HTMLElement &&
+		event.relatedTarget instanceof Node &&
+		event.currentTarget.contains(event.relatedTarget)
+	) {
+		return;
+	}
+	isArtifactsPanelRevealed.value = false;
+}
+
+function toggleArtifactsPanelPinned() {
+	if (!isArtifactsPanelPinningAvailable.value) return;
+
+	const nextPinned = !isArtifactsPanelPinned.value;
+	isArtifactsPanelPinned.value = nextPinned;
+	isArtifactsPanelRevealed.value = !nextPinned;
+}
+
+function enablePanelTransitionsAfterStableRender() {
+	artifactsPanelTransitionGate.enableAfterStableRender();
+	previewPanelTransitionGate.enableAfterStableRender();
+}
+
+function suppressPanelTransitionsUntilStableRender() {
+	artifactsPanelTransitionGate.suppressUntilStableRender();
+	previewPanelTransitionGate.suppressUntilStableRender();
+}
 
 // --- Preview panel resize (when canvas is visible) ---
-// Cap the preview at 50% of the *available* thread area, not the full window —
-// with the layout sidebar open the chat side would otherwise get less than 50%.
+// Cap the preview at 50% of the available thread area so the chat retains at
+// least the other half when side panels or app layout chrome are visible.
 const threadAreaRef = useTemplateRef<HTMLElement>('threadArea');
 const { width: threadAreaWidth } = useElementSize(threadAreaRef);
+const mainSidebarOccupiedWidth = computed(() =>
+	isMainSidebarCollapsed.value ? COLLAPSED_MAIN_SIDEBAR_WIDTH : (mainSidebarWidth.value ?? 0),
+);
+const instanceAiSidebarOccupiedWidth = computed(() =>
+	sidebar.collapsed.value ? 0 : (sidebar.width?.value ?? DEFAULT_INSTANCE_AI_SIDEBAR_WIDTH),
+);
+const availableWidthForPinnedArtifactsPanel = computed(
+	() => windowWidth.value - mainSidebarOccupiedWidth.value - instanceAiSidebarOccupiedWidth.value,
+);
+const isArtifactsPanelPinningAvailable = computed(
+	() =>
+		availableWidthForPinnedArtifactsPanel.value >= MIN_AVAILABLE_WIDTH_FOR_PINNED_ARTIFACTS_PANEL,
+);
+const isArtifactsPanelEffectivelyPinned = computed(
+	() => isArtifactsPanelPinningAvailable.value && isArtifactsPanelPinned.value,
+);
+const canShowArtifactsPanel = computed(
+	() => thread.hasMessages || (Boolean(props.threadId) && thread.isHydratingThread),
+);
+const showArtifactsPanelEdge = computed(
+	() =>
+		canShowArtifactsPanel.value &&
+		!preview.isPreviewVisible.value &&
+		!isArtifactsPanelEffectivelyPinned.value,
+);
+const showArtifactsPanel = computed(
+	() =>
+		canShowArtifactsPanel.value &&
+		!preview.isPreviewVisible.value &&
+		(isArtifactsPanelEffectivelyPinned.value || isArtifactsPanelRevealed.value),
+);
+const reserveArtifactsPanelLayout = computed(
+	() => showArtifactsPanel.value && isArtifactsPanelEffectivelyPinned.value,
+);
+const shouldSuppressContentLayoutTransitions = computed(
+	() => !isPreviewPanelTransitionEnabled.value,
+);
 const previewPanelWidth = ref(0);
 const isResizingPreview = ref(false);
+const isPreviewExpanded = ref(false);
 const previewMaxWidth = computed(() => Math.round(threadAreaWidth.value / 2));
+const previewPanelStyle = computed(() =>
+	isPreviewExpanded.value ? undefined : { width: `${previewPanelWidth.value}px` },
+);
+
+function togglePreviewExpanded() {
+	isPreviewExpanded.value = !isPreviewExpanded.value;
+}
 
 // Clamp preview width when the available area shrinks (sidebar open, window
 // resize, etc.)
@@ -122,13 +251,29 @@ function handlePreviewResize({ width }: { width: number }) {
 	previewPanelWidth.value = width;
 }
 
-// Re-compute default width when preview opens so it starts at 50% of the
-// currently-available thread area.
-watch(preview.isPreviewVisible, (visible) => {
-	if (visible) {
-		previewPanelWidth.value = Math.round(threadAreaWidth.value / 2);
-	}
-});
+function handlePreviewPanelAfterEnter() {
+	isPreviewPanelTransitioning.value = false;
+}
+
+function handlePreviewPanelAfterLeave() {
+	isPreviewPanelTransitioning.value = false;
+	isPreviewExpanded.value = false;
+}
+
+watch(
+	preview.isPreviewVisible,
+	(visible, wasVisible) => {
+		if (visible !== wasVisible) {
+			isPreviewPanelTransitioning.value = isPreviewPanelTransitionEnabled.value;
+		}
+
+		if (visible) {
+			isArtifactsPanelRevealed.value = false;
+			previewPanelWidth.value = Math.round(threadAreaWidth.value / 2);
+		}
+	},
+	{ flush: 'sync' },
+);
 
 // Late-initialize if the panel became visible before the ResizeObserver
 // reported the container size (otherwise the panel would render at 0px).
@@ -138,6 +283,39 @@ watch(threadAreaWidth, (width) => {
 	}
 });
 
+watch(isArtifactsPanelPinningAvailable, (isAvailable) => {
+	if (!isAvailable) {
+		isArtifactsPanelRevealed.value = false;
+	}
+});
+
+watch(canShowArtifactsPanel, (canShow) => {
+	if (!canShow) {
+		isArtifactsPanelRevealed.value = false;
+	}
+});
+
+watch(
+	() => props.threadId,
+	(threadId, previousThreadId) => {
+		if (threadId !== previousThreadId) {
+			suppressPanelTransitionsUntilStableRender();
+		}
+	},
+);
+
+watch(
+	() => thread.isHydratingThread,
+	(isHydrating) => {
+		if (isHydrating) {
+			artifactsPanelTransitionGate.suppress();
+			previewPanelTransitionGate.suppress();
+			return;
+		}
+		suppressPanelTransitionsUntilStableRender();
+	},
+);
+
 // --- Scroll management ---
 const scrollableRef = useTemplateRef<HTMLElement>('scrollable');
 // The actual scroll container is the reka-ui viewport inside N8nScrollArea,
@@ -200,6 +378,19 @@ watch(chatInputRef, (el) => {
 	}
 });
 
+// Reset scroll state when switching threads so new content auto-scrolls.
+watch(
+	() => props.threadId,
+	(threadId, previousThreadId) => {
+		if (threadId !== previousThreadId) {
+			userScrolledUp.value = false;
+			void nextTick(() => {
+				chatInputRef.value?.focus();
+			});
+		}
+	},
+);
+
 // --- Floating input dynamic padding ---
 const inputContainerRef = useTemplateRef<HTMLElement>('inputContainer');
 const inputAreaHeight = ref(120);
@@ -249,6 +440,7 @@ async function syncRouteToStore() {
 }
 
 onMounted(() => {
+	enablePanelTransitionsAfterStableRender();
 	void syncRouteToStore();
 	void nextTick(() => chatInputRef.value?.focus());
 });
@@ -315,19 +507,41 @@ function handleStop() {
 							store.debugMode = showDebugPanel;
 						"
 					/>
-					<N8nIconButton
-						v-if="!preview.isPreviewVisible.value"
-						icon="panel-right"
-						variant="ghost"
-						size="small"
-						icon-size="large"
-						@click="showArtifactsPanel = !showArtifactsPanel"
-					/>
+					<N8nTooltip
+						:content="artifactsPreviewToggleLabel"
+						placement="bottom"
+						:show-after="TOOLTIP_DELAY_MS"
+					>
+						<Transition name="preview-toggle-opacity" :css="isPreviewPanelTransitionEnabled">
+							<N8nIconButton
+								v-if="!preview.isPreviewVisible.value"
+								icon="panel-right"
+								variant="ghost"
+								size="small"
+								icon-size="large"
+								data-test-id="instance-ai-artifacts-preview-toggle"
+								:aria-label="artifactsPreviewToggleLabel"
+								:aria-pressed="preview.isPreviewVisible.value"
+								:disabled="!hasPreviewTabs"
+								@click="toggleArtifactsPreview"
+							/>
+						</Transition>
+					</N8nTooltip>
 				</template>
 			</InstanceAiViewHeader>
 
 			<!-- Content area: chat + artifacts side by side below header -->
-			<div :class="$style.contentArea">
+			<div
+				:class="[
+					$style.contentArea,
+					{
+						[$style.contentAreaWithPinnedArtifacts]: reserveArtifactsPanelLayout,
+					},
+					{ [$style.contentAreaWithoutLayoutTransitions]: shouldSuppressContentLayoutTransitions },
+				]"
+				:data-layout-transitions-enabled="isPreviewPanelTransitionEnabled"
+				data-test-id="instance-ai-content-area"
+			>
 				<div :class="$style.chatContent">
 					<N8nScrollArea :class="$style.scrollArea">
 						<div
@@ -343,8 +557,8 @@ function handleStop() {
 								/>
 							</TransitionGroup>
 							<!-- Builder sub-agents are extracted from their parent assistant
-							     messages and rendered here so they always sit at the bottom
-							     of the conversation. -->
+     messages and rendered here so they always sit at the bottom
+     of the conversation. -->
 							<div v-if="builderAgents.length" :class="$style.builderAgents">
 								<AgentSection
 									v-for="builder in builderAgents"
@@ -404,7 +618,36 @@ function handleStop() {
 				</div>
 
 				<!-- Artifacts panel (below header, beside chat) -->
-				<InstanceAiArtifactsPanel v-if="showArtifactsPanel && !preview.isPreviewVisible.value" />
+				<div
+					v-if="showArtifactsPanelEdge"
+					:class="$style.artifactsPanelEdge"
+					role="button"
+					tabindex="0"
+					:aria-label="i18n.baseText('instanceAi.artifactsPanel.showPanel')"
+					data-test-id="instance-ai-artifacts-sidebar-edge"
+					@click="revealArtifactsPanel"
+					@mouseenter="revealArtifactsPanel"
+					@focusin="revealArtifactsPanel"
+					@keydown.enter.prevent="revealArtifactsPanel"
+					@keydown.space.prevent="revealArtifactsPanel"
+				/>
+				<Transition :name="artifactsPanelTransitionName" :css="isArtifactsPanelTransitionEnabled">
+					<div
+						v-if="showArtifactsPanel"
+						:class="$style.artifactsPanelSlot"
+						data-test-id="instance-ai-artifacts-sidebar-slot"
+						@mouseenter="revealArtifactsPanel"
+						@mouseleave="hideArtifactsPanel()"
+						@focusin="revealArtifactsPanel"
+						@focusout="hideArtifactsPanel"
+					>
+						<InstanceAiArtifactsPanel
+							:is-pinned="isArtifactsPanelEffectivelyPinned"
+							:is-pinning-available="isArtifactsPanelPinningAvailable"
+							@toggle-pinned="toggleArtifactsPanelPinned"
+						/>
+					</div>
+				</Transition>
 
 				<!-- Overlay panels -->
 				<InstanceAiDebugPanel
@@ -418,64 +661,97 @@ function handleStop() {
 		</div>
 
 		<!-- Resizable preview panel (workflow OR datatable) -->
-		<N8nResizeWrapper
-			v-show="preview.isPreviewVisible.value"
-			:class="$style.canvasArea"
-			:width="previewPanelWidth"
-			:style="{ width: `${previewPanelWidth}px` }"
-			:min-width="400"
-			:max-width="previewMaxWidth"
-			:supported-directions="['left']"
-			:is-resizing-enabled="true"
-			:grid-size="8"
-			:outset="true"
-			@resize="handlePreviewResize"
-			@resizestart="isResizingPreview = true"
-			@resizeend="isResizingPreview = false"
+		<Transition
+			name="preview-panel-slide"
+			:css="isPreviewPanelTransitionEnabled"
+			@after-enter="handlePreviewPanelAfterEnter"
+			@after-leave="handlePreviewPanelAfterLeave"
 		>
-			<TabsRoot
-				v-model="preview.activeTabId.value"
-				orientation="horizontal"
-				:class="$style.previewPanel"
+			<div
+				v-show="preview.isPreviewVisible.value"
+				:class="[$style.canvasArea, { [$style.canvasAreaExpanded]: isPreviewExpanded }]"
+				:style="previewPanelStyle"
+				:data-expanded="isPreviewExpanded"
+				data-test-id="instance-ai-preview-panel"
 			>
-				<InstanceAiPreviewTabBar
-					:tabs="preview.allArtifactTabs.value"
-					:active-tab-id="preview.activeTabId.value"
-					@close="preview.closePreview()"
-				/>
-				<!-- Hoisted above the tab v-for so the iframe survives tab switches; tabs swap
-				     workflows via openWorkflow postMessage instead of remounting. -->
-				<div :class="$style.previewContent">
-					<InstanceAiWorkflowPreview
-						ref="workflowPreview"
-						:class="[
-							$style.previewSlot,
-							{ [$style.previewSlotHidden]: !!preview.activeDataTableId.value },
-						]"
-						:workflow-id="preview.activeWorkflowId.value"
-						:refresh-key="preview.workflowRefreshKey.value"
-						@iframe-ready="eventRelay.handleIframeReady"
-						@workflow-loaded="eventRelay.handleWorkflowLoaded"
-					/>
-					<InstanceAiDataTablePreview
-						v-if="preview.activeDataTableId.value"
-						:class="$style.previewSlot"
-						:data-table-id="preview.activeDataTableId.value"
-						:project-id="preview.activeDataTableProjectId.value"
-						:refresh-key="preview.dataTableRefreshKey.value"
-					/>
-				</div>
-			</TabsRoot>
-		</N8nResizeWrapper>
+				<N8nResizeWrapper
+					:width="previewPanelWidth"
+					:min-width="400"
+					:max-width="previewMaxWidth"
+					:supported-directions="['left']"
+					:is-resizing-enabled="!isPreviewExpanded"
+					:grid-size="8"
+					:outset="true"
+					@resize="handlePreviewResize"
+					@resizestart="isResizingPreview = true"
+					@resizeend="isResizingPreview = false"
+				>
+					<TabsRoot
+						v-model="preview.activeTabId.value"
+						orientation="horizontal"
+						:class="$style.previewPanel"
+					>
+						<InstanceAiPreviewTabBar
+							:tabs="preview.allArtifactTabs.value"
+							:active-tab-id="preview.activeTabId.value"
+							:is-expanded="isPreviewExpanded"
+							:preview-toggle-label="artifactsPreviewToggleLabel"
+							@toggle-preview="toggleArtifactsPreview"
+							@toggle-expanded="togglePreviewExpanded"
+						/>
+						<!-- Hoisted above the tab v-for so the iframe survives tab switches; tabs swap
+     workflows via openWorkflow postMessage instead of remounting. -->
+						<div :class="$style.previewContent">
+							<InstanceAiWorkflowPreview
+								ref="workflowPreview"
+								:class="[
+									$style.previewSlot,
+									{ [$style.previewSlotHidden]: !!preview.activeDataTableId.value },
+								]"
+								:workflow-id="preview.activeWorkflowId.value"
+								:refresh-key="preview.workflowRefreshKey.value"
+								@iframe-ready="eventRelay.handleIframeReady"
+								@workflow-loaded="eventRelay.handleWorkflowLoaded"
+							/>
+							<InstanceAiDataTablePreview
+								v-if="preview.activeDataTableId.value"
+								:class="$style.previewSlot"
+								:data-table-id="preview.activeDataTableId.value"
+								:project-id="preview.activeDataTableProjectId.value"
+								:refresh-key="preview.dataTableRefreshKey.value"
+							/>
+						</div>
+					</TabsRoot>
+				</N8nResizeWrapper>
+			</div>
+		</Transition>
 	</div>
 </template>
 
 <style lang="scss" module>
+@property --instance-ai-artifacts-layout-width {
+	syntax: '<length>';
+	inherits: true;
+	initial-value: 0;
+}
+
 .threadArea {
+	--instance-ai-artifacts-panel-width: 280px;
+	--instance-ai-panel-transition-duration: calc(var(--duration--snappy) + 80ms);
+	--instance-ai-panel-transition-easing: var(--easing--ease-in-out);
+
 	flex: 1;
 	display: flex;
 	min-width: 0;
 	overflow: hidden;
+	position: relative;
+	z-index: 0;
+
+	// Drop the stacking context while the workflow preview iframe NDV is
+	// fullscreen so its `z-index` can escape and paint above the sidebar.
+	&:has([data-test-id='workflow-preview-iframe'][data-ndv-open]) {
+		z-index: auto;
+	}
 }
 
 .chatArea {
@@ -519,6 +795,14 @@ function handleStop() {
 	}
 }
 
+.canvasAreaExpanded {
+	position: absolute;
+	inset: 0;
+	z-index: 4;
+	border-left: none;
+	background-color: var(--color--background--light-2);
+}
+
 .headerTitle {
 	overflow: hidden;
 	text-overflow: ellipsis;
@@ -536,10 +820,41 @@ function handleStop() {
 }
 
 .contentArea {
+	--instance-ai-artifacts-layout-width: 0;
+
 	display: flex;
 	flex: 1;
 	min-height: 0;
 	position: relative;
+	transition: --instance-ai-artifacts-layout-width var(--instance-ai-panel-transition-duration)
+		var(--instance-ai-panel-transition-easing);
+}
+
+.artifactsPanelEdge {
+	position: absolute;
+	top: 0;
+	right: 0;
+	bottom: 0;
+	z-index: 3;
+	width: var(--spacing--xl);
+	cursor: default;
+	outline: none;
+
+	&:focus-visible {
+		box-shadow: inset calc(-1 * var(--spacing--5xs)) 0 0 var(--color--primary);
+	}
+}
+
+.artifactsPanelSlot {
+	position: absolute;
+	top: 0;
+	right: 0;
+	bottom: 0;
+	z-index: 4;
+	width: var(--instance-ai-artifacts-panel-width);
+	min-width: var(--instance-ai-artifacts-panel-width);
+	display: flex;
+	overflow: hidden;
 }
 
 .chatContent {
@@ -557,12 +872,28 @@ function handleStop() {
 }
 
 .messageList {
+	width: calc(100% - var(--instance-ai-artifacts-layout-width));
 	max-width: 800px;
 	margin: 0 auto;
 	padding: var(--spacing--sm) var(--spacing--lg);
 	display: flex;
 	flex-direction: column;
 	gap: var(--spacing--xs);
+	transform: translateX(calc(var(--instance-ai-artifacts-layout-width) / -2));
+}
+
+.contentAreaWithPinnedArtifacts {
+	--instance-ai-artifacts-layout-width: var(--instance-ai-artifacts-panel-width);
+}
+
+.contentAreaWithoutLayoutTransitions {
+	transition: none;
+
+	.messageList,
+	.scrollButtonContainer,
+	.inputConstraint {
+		transition: none;
+	}
 }
 
 .builderAgents {
@@ -580,6 +911,7 @@ function handleStop() {
 	justify-content: center;
 	pointer-events: none;
 	z-index: 3;
+	transform: translateX(calc(var(--instance-ai-artifacts-layout-width) / -2));
 }
 
 .scrollToBottomButton {
@@ -610,8 +942,19 @@ function handleStop() {
 }
 
 .inputConstraint {
+	width: calc(100% - var(--instance-ai-artifacts-layout-width));
 	max-width: 750px;
 	margin: 0 auto;
+	transform: translateX(calc(var(--instance-ai-artifacts-layout-width) / -2));
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.contentArea,
+	.messageList,
+	.scrollButtonContainer,
+	.inputConstraint {
+		transition: none;
+	}
 }
 
 .previewPanel {
@@ -638,6 +981,8 @@ function handleStop() {
 </style>
 
 <style lang="scss">
+@use '@n8n/design-system/css/mixins/motion';
+
 .message-slide-enter-from {
 	opacity: 0;
 	transform: translateY(8px);
@@ -656,4 +1001,126 @@ function handleStop() {
 .fade-leave-active {
 	transition: opacity 0.2s ease;
 }
+
+.preview-panel-slide-enter-active,
+.preview-panel-slide-leave-active {
+	--preview-panel-slide-easing: var(--easing--ease-in-out);
+
+	transition:
+		width var(--instance-ai-panel-transition-duration, var(--duration--snappy))
+			var(--preview-panel-slide-easing),
+		min-width var(--instance-ai-panel-transition-duration, var(--duration--snappy))
+			var(--preview-panel-slide-easing),
+		opacity var(--instance-ai-panel-transition-duration, var(--duration--snappy))
+			var(--preview-panel-slide-easing);
+	overflow: hidden;
+	will-change: width, min-width, opacity, transform;
+
+	@media (prefers-reduced-motion: reduce) {
+		transition: none;
+		will-change: auto;
+	}
+}
+
+.preview-panel-slide-enter-active {
+	--animation--fade-in-right--easing: var(--preview-panel-slide-easing);
+	--animation--fade-in-right--duration: var(
+		--instance-ai-panel-transition-duration,
+		var(--duration--snappy)
+	);
+	--animation--fade-in-right--translate: var(--spacing--sm);
+
+	@include motion.fade-in-right;
+}
+
+.preview-panel-slide-leave-active {
+	--animation--fade-out-right--easing: var(--preview-panel-slide-easing);
+	--animation--fade-out-right--duration: var(
+		--instance-ai-panel-transition-duration,
+		var(--duration--snappy)
+	);
+	--animation--fade-out-right--translate: var(--spacing--sm);
+
+	@include motion.fade-out-right;
+}
+
+.preview-panel-slide-enter-from,
+.preview-panel-slide-leave-to {
+	width: 0 !important;
+	min-width: 0 !important;
+	opacity: 0;
+}
+
+.preview-toggle-opacity-enter-active,
+.preview-toggle-opacity-leave-active {
+	transition: opacity var(--instance-ai-panel-transition-duration, var(--duration--snappy)) linear;
+	will-change: opacity;
+
+	@media (prefers-reduced-motion: reduce) {
+		transition: none;
+		will-change: auto;
+	}
+}
+
+.preview-toggle-opacity-enter-from,
+.preview-toggle-opacity-leave-to {
+	opacity: 0;
+}
+
+.preview-toggle-opacity-leave-active {
+	pointer-events: none;
+}
+
+.artifacts-panel-fade-enter-active,
+.artifacts-panel-fade-leave-active {
+	--artifacts-panel-slide-enter-easing: var(--easing--ease-out);
+	--artifacts-panel-slide-exit-easing: var(--easing--ease-in);
+	--animation--fade-in-right--duration: var(
+		--instance-ai-panel-transition-duration,
+		var(--duration--snappy)
+	);
+	--animation--fade-in-right--easing: var(--artifacts-panel-slide-enter-easing);
+	--animation--fade-in-right--translate: 100%;
+	--animation--fade-out-right--duration: var(
+		--instance-ai-panel-transition-duration,
+		var(--duration--snappy)
+	);
+	--animation--fade-out-right--easing: var(--artifacts-panel-slide-exit-easing);
+	--animation--fade-out-right--translate: 100%;
+
+	will-change: opacity, transform;
+
+	@media (prefers-reduced-motion: reduce) {
+		will-change: auto;
+	}
+}
+
+.artifacts-panel-preview-enter-active,
+.artifacts-panel-preview-leave-active {
+	transition: opacity var(--instance-ai-panel-transition-duration, var(--duration--snappy)) linear;
+
+	will-change: opacity;
+
+	@media (prefers-reduced-motion: reduce) {
+		will-change: auto;
+	}
+}
+
+.artifacts-panel-preview-enter-from,
+.artifacts-panel-preview-leave-to {
+	opacity: 0;
+}
+
+.artifacts-panel-fade-enter-active {
+	@include motion.fade-in-right;
+}
+
+.artifacts-panel-fade-leave-active {
+	@include motion.fade-out-right;
+	pointer-events: none;
+}
+
+.artifacts-panel-preview-leave-active {
+	pointer-events: none;
+}
 </style>
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiView.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiView.vue
index 3b31e8a5ba1..bc3d5346d92 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiView.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/InstanceAiView.vue
@@ -40,6 +40,7 @@ function handleSidebarResize({ width }: { width: number }) {
 
 provide(SidebarStateKey, {
 	collapsed: sidebarCollapsed,
+	width: sidebarWidth,
 	toggle: toggleSidebarCollapse,
 });
 
@@ -128,7 +129,7 @@ onUnmounted(() => {
 	display: flex;
 	height: 100%;
 	width: 100%;
-	min-width: 900px;
+	min-width: 0;
 	overflow: hidden;
 	position: relative;
 	z-index: 0;
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiArtifactsPanel.test.ts b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiArtifactsPanel.test.ts
new file mode 100644
index 00000000000..e433e2d38a3
--- /dev/null
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiArtifactsPanel.test.ts
@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fireEvent } from '@testing-library/vue';
+import { defineComponent, h, nextTick, reactive } from 'vue';
+import { createComponentRenderer } from '@/__tests__/render';
+import type { TaskList } from '@n8n/api-types';
+import type { ResourceEntry } from '../useResourceRegistry';
+import InstanceAiArtifactsPanel from '../components/InstanceAiArtifactsPanel.vue';
+
+const storeState = reactive({
+	currentTasks: undefined as TaskList | undefined,
+	producedArtifacts: new Map<string, ResourceEntry>(),
+});
+
+vi.mock('../instanceAi.store', () => ({
+	useThread: vi.fn(() => storeState),
+}));
+
+const renderComponent = createComponentRenderer(InstanceAiArtifactsPanel, {
+	global: {
+		stubs: {
+			ConnectionsCard: defineComponent({
+				props: {
+					dropdownPortalTarget: { type: HTMLElement, required: false },
+				},
+				setup(props) {
+					return () =>
+						h('section', {
+							'data-test-id': 'connections-card',
+							'data-portal-target-tag': props.dropdownPortalTarget?.tagName ?? '',
+						});
+				},
+			}),
+		},
+	},
+});
+
+describe('InstanceAiArtifactsPanel', () => {
+	beforeEach(() => {
+		storeState.currentTasks = undefined;
+		storeState.producedArtifacts = new Map<string, ResourceEntry>();
+	});
+
+	it('keeps empty artifacts and connections sections visible without an empty tasks section', () => {
+		const { getByText, getByTestId, queryByText } = renderComponent();
+
+		expect(getByTestId('instance-ai-artifacts-sidebar')).toBeInTheDocument();
+		expect(getByTestId('instance-ai-artifacts-sidebar-group')).toBeInTheDocument();
+		expect(getByTestId('instance-ai-artifacts-sidebar-pin')).toHaveAttribute(
+			'aria-label',
+			'Unpin panel',
+		);
+		expect(getByTestId('instance-ai-artifacts-sidebar-pin')).toHaveAttribute(
+			'aria-pressed',
+			'true',
+		);
+		expect(getByText('No artifacts yet')).toBeInTheDocument();
+		expect(queryByText('To-do list')).not.toBeInTheDocument();
+		expect(queryByText('No tasks yet')).not.toBeInTheDocument();
+		expect(getByTestId('connections-card')).toBeInTheDocument();
+	});
+
+	it('anchors connection menus inside the panel', async () => {
+		const { getByTestId } = renderComponent();
+
+		await nextTick();
+
+		expect(getByTestId('connections-card')).toHaveAttribute('data-portal-target-tag', 'ASIDE');
+	});
+
+	it('emits when the pin button is clicked and reflects the unpinned label', async () => {
+		const { emitted, getByTestId } = renderComponent({ props: { isPinned: false } });
+		const pinButton = getByTestId('instance-ai-artifacts-sidebar-pin');
+
+		expect(pinButton).toHaveAttribute('aria-label', 'Pin panel');
+		expect(pinButton).toHaveAttribute('aria-pressed', 'false');
+
+		await fireEvent.click(pinButton);
+
+		expect(emitted('togglePinned')).toHaveLength(1);
+	});
+
+	it('hides the pin button when pinning is unavailable', () => {
+		const { queryByTestId } = renderComponent({ props: { isPinningAvailable: false } });
+
+		expect(queryByTestId('instance-ai-artifacts-sidebar-pin')).not.toBeInTheDocument();
+	});
+
+	it('opens artifacts in preview and shows tasks without progress counts', async () => {
+		const openWorkflowPreview = vi.fn();
+		storeState.producedArtifacts = new Map<string, ResourceEntry>([
+			[
+				'wf-1',
+				{
+					type: 'workflow',
+					id: 'wf-1',
+					name: 'Sales follow-up workflow',
+				},
+			],
+		]);
+		storeState.currentTasks = {
+			tasks: [
+				{ id: 'task-1', description: 'Build the workflow', status: 'done' },
+				{ id: 'task-2', description: 'Review the workflow', status: 'in_progress' },
+			],
+		};
+
+		const { getByRole, getByText, queryByText } = renderComponent({
+			global: {
+				provide: {
+					openWorkflowPreview,
+				},
+			},
+		});
+
+		const artifactLink = getByRole('link', { name: 'Open Sales follow-up workflow' });
+		expect(artifactLink).toHaveAttribute('href', '/workflow/wf-1');
+		expect(getByText('To-do list')).toBeInTheDocument();
+		expect(getByText('Build the workflow')).toBeInTheDocument();
+		expect(queryByText('1/2')).not.toBeInTheDocument();
+
+		await fireEvent.click(artifactLink);
+
+		expect(openWorkflowPreview).toHaveBeenCalledWith('wf-1');
+	});
+});
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiPreviewTabBar.test.ts b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiPreviewTabBar.test.ts
index 650fde789aa..6b91dd2aaf3 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiPreviewTabBar.test.ts
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiPreviewTabBar.test.ts
@@ -36,15 +36,20 @@ const Wrapper = defineComponent({
 	props: {
 		tabs: { type: Array as () => ArtifactTab[], required: true },
 		activeTabId: { type: String, default: undefined },
+		isExpanded: { type: Boolean, default: false },
+		previewToggleLabel: { type: String, default: undefined },
 	},
-	emits: ['close'],
+	emits: ['togglePreview', 'toggleExpanded'],
 	setup(props, { emit }) {
 		return () =>
 			h(TabsRoot, { modelValue: props.activeTabId }, () =>
 				h(InstanceAiPreviewTabBar, {
 					tabs: props.tabs,
 					activeTabId: props.activeTabId,
-					onClose: () => emit('close'),
+					isExpanded: props.isExpanded,
+					previewToggleLabel: props.previewToggleLabel,
+					onTogglePreview: () => emit('togglePreview'),
+					onToggleExpanded: () => emit('toggleExpanded'),
 				}),
 			);
 	},
@@ -83,17 +88,49 @@ describe('InstanceAiPreviewTabBar', () => {
 		expect(inactive?.getAttribute('data-state')).toBe('inactive');
 	});
 
-	it('emits close when the collapse button is clicked', async () => {
+	it('emits toggleExpanded when the expand button is clicked', async () => {
 		const { container, emitted } = renderComponent({
 			props: { tabs: [workflowTab], activeTabId: 'wf-1' },
 		});
 
-		const collapseButton = container.querySelector<HTMLButtonElement>(
-			'[data-test-id="instance-ai-preview-close"]',
+		const expandButton = container.querySelector<HTMLButtonElement>(
+			'[data-test-id="instance-ai-preview-expand-toggle"]',
 		);
-		expect(collapseButton).not.toBeNull();
-		await fireEvent.click(collapseButton!);
+		expect(expandButton).not.toBeNull();
+		expect(expandButton).toHaveAttribute('aria-label', 'Expand panel');
+		await fireEvent.click(expandButton!);
 
-		expect(emitted().close).toBeTruthy();
+		expect(emitted().toggleExpanded).toBeTruthy();
+	});
+
+	it('emits togglePreview when the preview toggle is clicked', async () => {
+		const { getByTestId, emitted } = renderComponent({
+			props: {
+				tabs: [workflowTab],
+				activeTabId: 'wf-1',
+				previewToggleLabel: 'Hide artifacts preview',
+			},
+		});
+
+		const toggleButton = getByTestId('instance-ai-artifacts-preview-toggle');
+		expect(toggleButton).toHaveAttribute('aria-label', 'Hide artifacts preview');
+		expect(toggleButton).toHaveAttribute('aria-pressed', 'true');
+
+		await fireEvent.click(toggleButton);
+
+		expect(emitted().togglePreview).toBeTruthy();
+	});
+
+	it('labels the size toggle as collapse when the panel is expanded', () => {
+		const { container } = renderComponent({
+			props: { tabs: [workflowTab], activeTabId: 'wf-1', isExpanded: true },
+		});
+
+		const collapseButton = container.querySelector<HTMLButtonElement>(
+			'[data-test-id="instance-ai-preview-expand-toggle"]',
+		);
+
+		expect(collapseButton).not.toBeNull();
+		expect(collapseButton).toHaveAttribute('aria-label', 'Collapse panel');
 	});
 });
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiThreadView.test.ts b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiThreadView.test.ts
index 75f49df77cc..17abb2b9093 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiThreadView.test.ts
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/__tests__/InstanceAiThreadView.test.ts
@@ -9,6 +9,10 @@ import { useInstanceAiStore, type ThreadRuntime } from '../instanceAi.store';
 import { usePushConnectionStore } from '@/app/stores/pushConnection.store';
 import { SidebarStateKey } from '../instanceAiLayout';
 
+const mockWindowSizeState = vi.hoisted(() => ({
+	width: { value: 1200 },
+}));
+
 vi.mock('@/app/composables/usePageRedirectionHelper', () => ({
 	usePageRedirectionHelper: () => ({ goToUpgrade: vi.fn() }),
 }));
@@ -30,7 +34,7 @@ vi.mock('vue-router', async (importOriginal) => ({
 vi.mock('@vueuse/core', async (importOriginal) => ({
 	...(await importOriginal()),
 	useScroll: () => ({ arrivedState: { bottom: true } }),
-	useWindowSize: () => ({ width: ref(1200) }),
+	useWindowSize: () => ({ width: mockWindowSizeState.width }),
 }));
 
 const InstanceAiInputStub = defineComponent({
@@ -73,6 +77,7 @@ describe('InstanceAiThreadView', () => {
 		thread = {
 			id: 'thread-1',
 			messages: [],
+			hasMessages: false,
 			sseState: 'connected',
 			isStreaming: false,
 			isSendingMessage: false,
@@ -106,6 +111,7 @@ describe('InstanceAiThreadView', () => {
 				updatedAt: '2026-04-01T00:00:00.000Z',
 			},
 		] as typeof store.threads;
+		mockWindowSizeState.width.value = 1200;
 
 		// `useExecutionPushEvents` (consumed by ThreadView) registers a push
 		// listener and stores the returned removeListener; it gets invoked on
@@ -166,4 +172,25 @@ describe('InstanceAiThreadView', () => {
 		});
 		expect(thread.loadHistoricalMessages).toHaveBeenCalledWith();
 	});
+
+	it('uses edge reveal when the viewport is too narrow for pinned artifacts', async () => {
+		mockWindowSizeState.width.value = 900;
+		thread.messages = [
+			{
+				id: 'msg-1',
+				role: 'assistant',
+				content: 'already loaded',
+				isStreaming: false,
+				createdAt: '2026-04-01T00:00:00.000Z',
+			},
+		] as typeof thread.messages;
+		Object.defineProperty(thread, 'hasMessages', { value: true, configurable: true });
+
+		const { getByTestId, queryByTestId } = renderView({ props: { threadId: 'thread-1' } });
+
+		await vi.waitFor(() => {
+			expect(getByTestId('instance-ai-artifacts-sidebar-edge')).toBeInTheDocument();
+		});
+		expect(queryByTestId('instance-ai-artifacts-sidebar-slot')).not.toBeInTheDocument();
+	});
 });
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionRow.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionRow.vue
index 94fa513ba95..676fe40cfae 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionRow.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionRow.vue
@@ -13,6 +13,7 @@ const props = defineProps<{
 	icon: IconName;
 	status: ConnectionStatus;
 	actions: RowAction[];
+	dropdownPortalTarget?: HTMLElement;
 }>();
 
 const emit = defineEmits<{
@@ -77,6 +78,7 @@ function handleSelect(action: RowAction) {
 			v-if="menuItems.length > 0"
 			:items="menuItems"
 			placement="bottom-end"
+			:portal-target="dropdownPortalTarget"
 			@select="handleSelect"
 		/>
 	</div>
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionsCard.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionsCard.vue
index cfb4efeac22..d08c5aafe56 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionsCard.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/ConnectionsCard.vue
@@ -19,8 +19,11 @@ const i18n = useI18n();
 const uiStore = useUIStore();
 const store = useInstanceAiSettingsStore();
 
-const connections = computed(() => store.connections);
+const props = defineProps<{
+	dropdownPortalTarget?: HTMLElement;
+}>();
 
+const connections = computed(() => store.connections);
 const isVisible = computed(
 	() =>
 		!store.isLocalGatewayDisabledByAdmin &&
@@ -90,19 +93,21 @@ async function handleRemove(type: ConnectionType) {
 </script>
 
 <template>
-	<div v-if="isVisible" :class="[$style.section, $style.card]">
+	<div v-if="isVisible" :class="$style.section">
 		<div :class="$style.header">
-			<N8nHeading tag="h3" size="small" bold>
+			<N8nHeading tag="h3" size="small" :class="$style.sectionTitle">
 				{{ i18n.baseText('instanceAi.connections.title') }}
 			</N8nHeading>
-			<N8nDropdownMenu
-				v-if="hasAddableConnection"
-				:items="addItems"
-				:activator-icon="{ type: 'icon', value: 'plus' }"
-				placement="bottom-end"
-				data-test-id="instance-ai-connections-add"
-				@select="openModal"
-			/>
+			<div v-if="hasAddableConnection" :class="$style.headerActions">
+				<N8nDropdownMenu
+					:items="addItems"
+					:activator-icon="{ type: 'icon', value: 'plus' }"
+					placement="bottom-end"
+					:portal-target="props.dropdownPortalTarget"
+					data-test-id="instance-ai-connections-add"
+					@select="openModal"
+				/>
+			</div>
 		</div>
 
 		<div v-if="connections.length > 0" :class="$style.list">
@@ -114,6 +119,7 @@ async function handleRemove(type: ConnectionType) {
 				:icon="ICON_MAP[conn.type]"
 				:status="conn.status"
 				:actions="getRowActions(conn.type, conn.status)"
+				:dropdown-portal-target="props.dropdownPortalTarget"
 				@connect="openModal(conn.type)"
 				@disconnect="handleDisconnect(conn.type)"
 				@open-settings="openModal(conn.type)"
@@ -138,15 +144,20 @@ async function handleRemove(type: ConnectionType) {
 
 <style lang="scss" module>
 .section {
+	position: relative;
 	display: flex;
 	flex-direction: column;
-}
+	padding: var(--spacing--2xs);
+	padding-top: var(--spacing--sm);
 
-.card {
-	border: var(--border);
-	border-radius: var(--radius--lg);
-	padding: var(--spacing--sm);
-	background: var(--color--background--light-2);
+	&::before {
+		content: '';
+		position: absolute;
+		top: 0;
+		left: var(--spacing--sm);
+		right: var(--spacing--sm);
+		border-top: var(--border);
+	}
 }
 
 .header {
@@ -155,6 +166,17 @@ async function handleRemove(type: ConnectionType) {
 	justify-content: space-between;
 	gap: var(--spacing--2xs);
 	margin-bottom: var(--spacing--2xs);
+	padding: 0 var(--spacing--2xs);
+}
+
+.sectionTitle {
+	color: var(--text-color--subtle);
+}
+
+.headerActions {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing--4xs);
 }
 
 .list {
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiArtifactsPanel.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiArtifactsPanel.vue
index 0ee62708618..f858e96d92f 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiArtifactsPanel.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiArtifactsPanel.vue
@@ -1,6 +1,12 @@
 <script lang="ts" setup>
-import { computed, inject } from 'vue';
-import { N8nHeading, N8nIcon } from '@n8n/design-system';
+import { computed, inject, ref } from 'vue';
+import {
+	N8nHeading,
+	N8nIcon,
+	N8nIconButton,
+	N8nTooltip,
+	TOOLTIP_DELAY_MS,
+} from '@n8n/design-system';
 import { useI18n } from '@n8n/i18n';
 import { useThread } from '../instanceAi.store';
 import type { TaskItem } from '@n8n/api-types';
@@ -8,8 +14,16 @@ import type { IconName } from '@n8n/design-system';
 import type { ResourceEntry } from '../useResourceRegistry';
 import ConnectionsCard from './ConnectionsCard.vue';
 
+const props = withDefaults(defineProps<{ isPinned?: boolean; isPinningAvailable?: boolean }>(), {
+	isPinned: true,
+	isPinningAvailable: true,
+});
+
+const emit = defineEmits<{ togglePinned: [] }>();
+
 const i18n = useI18n();
 const thread = useThread();
+const panelRef = ref<HTMLElement>();
 const openPreview = inject<((id: string) => void) | undefined>('openWorkflowPreview', undefined);
 const openDataTablePreview = inject<((id: string, projectId: string) => void) | undefined>(
 	'openDataTablePreview',
@@ -17,39 +31,32 @@ const openDataTablePreview = inject<((id: string, projectId: string) => void) |
 );
 
 function handleArtifactClick(artifact: ResourceEntry, e: MouseEvent) {
+	if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+
 	if (artifact.type === 'workflow' && artifact.id) {
-		if (e.metaKey || e.ctrlKey) {
-			window.open(`/workflow/${artifact.id}`, '_blank');
-			return;
-		}
-		openPreview?.(artifact.id);
+		if (!openPreview) return;
+		e.preventDefault();
+		openPreview(artifact.id);
 	} else if (artifact.type === 'data-table' && artifact.id) {
-		if (e.metaKey || e.ctrlKey) {
-			window.open('/data-tables', '_blank');
-			return;
-		}
-		if (artifact.projectId) {
-			openDataTablePreview?.(artifact.id, artifact.projectId);
-		}
+		if (!artifact.projectId || !openDataTablePreview) return;
+		e.preventDefault();
+		openDataTablePreview(artifact.id, artifact.projectId);
 	}
 }
 
 // --- Tasks ---
 const tasks = computed(() => thread.currentTasks);
-
-const doneCount = computed(() => {
-	if (!tasks.value) return 0;
-	return tasks.value.tasks.filter((t) => t.status === 'done').length;
-});
+const visibleTasks = computed(() => tasks.value?.tasks ?? []);
+const hasTasks = computed(() => visibleTasks.value.length > 0);
 
 const statusIconMap: Record<
 	TaskItem['status'],
-	{ icon: string; spin: boolean; className: string }
+	{ icon: IconName; spin: boolean; className: string }
 > = {
 	todo: { icon: 'circle', spin: false, className: 'todoIcon' },
 	in_progress: { icon: 'spinner', spin: true, className: 'inProgressIcon' },
 	done: { icon: 'check', spin: false, className: 'doneIcon' },
-	failed: { icon: 'x-circle', spin: false, className: 'failedIcon' },
+	failed: { icon: 'circle-x', spin: false, className: 'failedIcon' },
 	cancelled: { icon: 'ban', spin: false, className: 'cancelledIcon' },
 };
 
@@ -68,80 +75,122 @@ const artifactIconMap: Record<string, IconName> = {
 	workflow: 'workflow',
 	'data-table': 'table',
 };
+
+function artifactHref(artifact: ResourceEntry) {
+	if (artifact.type === 'workflow') return `/workflow/${artifact.id}`;
+	if (artifact.type === 'data-table') {
+		return artifact.projectId
+			? `/projects/${artifact.projectId}/datatables/${artifact.id}`
+			: '/data-tables';
+	}
+	return '#';
+}
+
+function openArtifactLabel(name: string) {
+	return i18n.baseText('instanceAi.artifactsPanel.openArtifact', { interpolate: { name } });
+}
+
+const pinButtonLabel = computed(() =>
+	i18n.baseText(
+		props.isPinned ? 'instanceAi.artifactsPanel.unpinPanel' : 'instanceAi.artifactsPanel.pinPanel',
+	),
+);
 </script>
 
 <template>
-	<div :class="$style.panel">
-		<!-- Artifacts section -->
-		<div :class="[$style.section, $style.card]">
-			<N8nHeading :class="$style.sectionTitle" tag="h3" size="small" bold>
-				{{ i18n.baseText('instanceAi.artifactsPanel.title') }}
-			</N8nHeading>
-
-			<div v-if="artifacts.length > 0" :class="$style.artifactList">
-				<div
-					v-for="artifact in artifacts"
-					:key="artifact.id"
-					:class="[$style.artifactRow, artifact.archived && $style.artifactRowArchived]"
-					@click="handleArtifactClick(artifact, $event)"
-				>
-					<span :class="$style.artifactIconWrap">
-						<N8nIcon
-							:icon="artifactIconMap[artifact.type] ?? 'file'"
-							size="large"
-							:class="$style.artifactIcon"
+	<aside ref="panelRef" :class="$style.panel" data-test-id="instance-ai-artifacts-sidebar">
+		<div :class="$style.group" data-test-id="instance-ai-artifacts-sidebar-group">
+			<!-- Artifacts section -->
+			<div :class="$style.section">
+				<div :class="$style.sectionHeader">
+					<N8nHeading tag="h3" size="small" :class="$style.sectionTitle">
+						{{ i18n.baseText('instanceAi.artifactsPanel.title') }}
+					</N8nHeading>
+					<N8nTooltip
+						v-if="props.isPinningAvailable"
+						:content="pinButtonLabel"
+						placement="left"
+						:show-after="TOOLTIP_DELAY_MS"
+					>
+						<N8nIconButton
+							icon="pin"
+							variant="ghost"
+							size="small"
+							icon-size="medium"
+							:aria-label="pinButtonLabel"
+							:aria-pressed="props.isPinned"
+							:class="[$style.pinButton, { [$style.pinButtonPinned]: props.isPinned }]"
+							data-test-id="instance-ai-artifacts-sidebar-pin"
+							@click="emit('togglePinned')"
 						/>
-					</span>
-					<span :class="$style.artifactName">{{ artifact.name }}</span>
-					<span v-if="artifact.archived" :class="$style.archivedBadge">
-						{{ i18n.baseText('instanceAi.artifactsPanel.archived') }}
-					</span>
+					</N8nTooltip>
+				</div>
+
+				<div v-if="artifacts.length > 0" :class="$style.artifactList">
+					<a
+						v-for="artifact in artifacts"
+						:key="artifact.id"
+						:href="artifactHref(artifact)"
+						:class="[$style.artifactRow, artifact.archived && $style.artifactRowArchived]"
+						:title="artifact.name"
+						:aria-label="openArtifactLabel(artifact.name)"
+						@click="handleArtifactClick(artifact, $event)"
+					>
+						<span :class="$style.artifactIconWrap">
+							<N8nIcon
+								:icon="artifactIconMap[artifact.type] ?? 'file'"
+								size="large"
+								:class="$style.artifactIcon"
+							/>
+						</span>
+						<span :class="$style.artifactName">{{ artifact.name }}</span>
+						<span v-if="artifact.archived" :class="$style.archivedBadge">
+							{{ i18n.baseText('instanceAi.artifactsPanel.archived') }}
+						</span>
+					</a>
+				</div>
+
+				<div v-else :class="$style.emptyState">
+					<span>{{ i18n.baseText('instanceAi.artifactsPanel.noArtifacts') }}</span>
 				</div>
 			</div>
 
-			<div v-else :class="$style.emptyState">
-				<div :class="$style.emptyIcons">
-					<N8nIcon icon="workflow" :size="30" :class="$style.emptyIcon" />
-					<N8nIcon icon="table" :size="30" :class="$style.emptyIcon" />
+			<!-- Tasks section -->
+			<div v-if="hasTasks" :class="$style.section">
+				<div :class="$style.sectionHeader">
+					<N8nHeading tag="h3" size="small" :class="$style.sectionTitle">
+						{{ i18n.baseText('instanceAi.artifactsPanel.tasks') }}
+					</N8nHeading>
+				</div>
+
+				<div :class="$style.taskList">
+					<div
+						v-for="task in visibleTasks"
+						:key="task.id"
+						:class="[
+							$style.task,
+							task.status === 'done' ? $style.doneTask : '',
+							task.status === 'failed' ? $style.failedTask : '',
+							task.status === 'cancelled' ? $style.cancelledTask : '',
+						]"
+					>
+						<N8nIcon
+							:icon="statusIconMap[task.status].icon"
+							:class="$style[statusIconMap[task.status].className]"
+							:spin="statusIconMap[task.status].spin"
+							size="medium"
+						/>
+						<span :class="$style.taskDescription" :title="task.description">{{
+							task.description
+						}}</span>
+					</div>
 				</div>
-				<span>{{ i18n.baseText('instanceAi.artifactsPanel.noArtifacts') }}</span>
 			</div>
+
+			<!-- Connections section -->
+			<ConnectionsCard :dropdown-portal-target="panelRef" />
 		</div>
-
-		<!-- Tasks section -->
-		<div v-if="tasks" :class="[$style.section, $style.card]">
-			<N8nHeading :class="$style.sectionTitle" tag="h3" size="small" bold>
-				{{ i18n.baseText('instanceAi.artifactsPanel.tasks') }}
-				<span :class="$style.progress">{{ doneCount }}/{{ tasks.tasks.length }}</span>
-			</N8nHeading>
-
-			<div :class="$style.taskList">
-				<div
-					v-for="task in tasks.tasks"
-					:key="task.id"
-					:class="[
-						$style.task,
-						task.status === 'done' ? $style.doneTask : '',
-						task.status === 'failed' ? $style.failedTask : '',
-						task.status === 'cancelled' ? $style.cancelledTask : '',
-					]"
-				>
-					<N8nIcon
-						:icon="statusIconMap[task.status].icon as IconName"
-						:class="$style[statusIconMap[task.status].className]"
-						:spin="statusIconMap[task.status].spin"
-						size="medium"
-					/>
-					<span :class="$style.taskDescription" :title="task.description">{{
-						task.description
-					}}</span>
-				</div>
-			</div>
-		</div>
-
-		<!-- Connections section -->
-		<ConnectionsCard />
-	</div>
+	</aside>
 </template>
 
 <style lang="scss" module>
@@ -150,34 +199,67 @@ const artifactIconMap: Record<string, IconName> = {
 	flex-shrink: 0;
 	display: flex;
 	flex-direction: column;
-	gap: var(--spacing--sm);
-	padding: var(--spacing--sm);
+	padding: 0 var(--spacing--sm) var(--spacing--sm);
 	overflow-y: auto;
 }
 
+.group {
+	border: var(--border);
+	border-radius: var(--radius--xl);
+	background: var(--color--background--light-3);
+	box-shadow: var(--shadow--xs);
+	overflow: hidden;
+}
+
 .section {
+	position: relative;
 	display: flex;
 	flex-direction: column;
+	padding: var(--spacing--2xs);
+
+	& + & {
+		padding-top: var(--spacing--sm);
+	}
+
+	& + &::before {
+		content: '';
+		position: absolute;
+		top: 0;
+		left: var(--spacing--sm);
+		right: var(--spacing--sm);
+		border-top: var(--border);
+	}
 }
 
-.card {
-	border: var(--border);
-	border-radius: var(--radius--lg);
-	padding: var(--spacing--sm);
-	background: var(--color--background--light-2);
-}
-
-.sectionTitle {
+.sectionHeader {
 	margin-bottom: var(--spacing--2xs);
+	padding: 0 var(--spacing--2xs);
 	display: flex;
-	align-items: baseline;
+	align-items: center;
+	justify-content: space-between;
 	gap: var(--spacing--3xs);
 }
 
-.progress {
-	font-size: var(--font-size--2xs);
+.sectionTitle {
+	color: var(--text-color--subtle);
+}
+
+.pinButton {
 	color: var(--color--text--tint-1);
-	font-weight: var(--font-weight--regular);
+
+	&:hover,
+	&:focus-visible {
+		color: var(--color--text--shade-1);
+	}
+}
+
+.pinButtonPinned {
+	color: var(--color--text--shade-1);
+
+	:deep(svg),
+	:deep(path) {
+		fill: currentColor;
+	}
 }
 
 /* Artifact list */
@@ -189,22 +271,23 @@ const artifactIconMap: Record<string, IconName> = {
 .artifactRow {
 	display: flex;
 	align-items: center;
-	gap: var(--spacing--xs);
-	padding: var(--spacing--2xs) 0;
+	gap: var(--spacing--2xs);
+	padding: var(--spacing--2xs);
 	cursor: pointer;
 	border-radius: var(--radius);
-	transition: background-color 0.2s ease;
+	color: var(--color--text);
+	text-decoration: none;
+	transition: background-color var(--animation--duration--snappy) var(--animation--easing);
 
-	&:hover {
-		background: var(--color--foreground--tint-2);
+	&:hover,
+	&:focus-visible {
+		background: var(--background--hover);
+		outline: none;
+		text-decoration: none;
+	}
 
-		.artifactName {
-			color: var(--color--primary);
-		}
-
-		.artifactIcon {
-			color: var(--color--primary);
-		}
+	&:visited {
+		color: var(--color--text);
 	}
 }
 
@@ -212,9 +295,6 @@ const artifactIconMap: Record<string, IconName> = {
 	display: inline-flex;
 	align-items: center;
 	justify-content: center;
-	padding: var(--spacing--4xs);
-	background: var(--color--foreground--tint-1);
-	border-radius: var(--radius);
 	flex-shrink: 0;
 }
 
@@ -224,6 +304,7 @@ const artifactIconMap: Record<string, IconName> = {
 
 .artifactName {
 	font-size: var(--font-size--sm);
+	line-height: var(--line-height--lg);
 	color: var(--color--text--shade-1);
 	overflow: hidden;
 	text-overflow: ellipsis;
@@ -260,18 +341,6 @@ const artifactIconMap: Record<string, IconName> = {
 	color: var(--color--text--tint-1);
 }
 
-.emptyIcons {
-	display: flex;
-	gap: var(--spacing--2xs);
-}
-
-.emptyIcon {
-	color: var(--color--text--tint-1);
-	padding: var(--spacing--4xs);
-	background: var(--color--foreground--tint-1);
-	border-radius: var(--radius--lg);
-}
-
 /* Task list */
 .taskList {
 	display: flex;
@@ -282,7 +351,8 @@ const artifactIconMap: Record<string, IconName> = {
 	display: flex;
 	align-items: center;
 	gap: var(--spacing--2xs);
-	padding: var(--spacing--2xs) 0;
+	padding: var(--spacing--3xs) 0;
+	padding-left: var(--spacing--2xs);
 	font-size: var(--font-size--sm);
 	line-height: var(--line-height--lg);
 }
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiPreviewTabBar.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiPreviewTabBar.vue
index dab5cdac950..39c87e9b126 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiPreviewTabBar.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiPreviewTabBar.vue
@@ -11,33 +11,82 @@ import {
 	TabsList,
 	TabsTrigger,
 } from 'reka-ui';
-import { nextTick, watch } from 'vue';
+import { computed, nextTick, ref, watch } from 'vue';
 import { useClipboard } from '@/app/composables/useClipboard';
 import { useToast } from '@/app/composables/useToast';
 import type { ArtifactTab } from '../useCanvasPreview';
 
-const props = defineProps<{
-	tabs: ArtifactTab[];
-	activeTabId?: string;
-}>();
+const props = withDefaults(
+	defineProps<{
+		tabs: ArtifactTab[];
+		activeTabId?: string;
+		isExpanded?: boolean;
+		previewToggleLabel?: string;
+	}>(),
+	{
+		isExpanded: false,
+		previewToggleLabel: undefined,
+	},
+);
 
 const emit = defineEmits<{
-	close: [];
+	togglePreview: [];
+	toggleExpanded: [];
 }>();
 
 const i18n = useI18n();
 const clipboard = useClipboard();
 const toast = useToast();
+const tabListRef = ref<HTMLElement | null>(null);
+const sizeToggleLabel = computed(() =>
+	i18n.baseText(
+		props.isExpanded ? 'instanceAi.previewTabBar.collapse' : 'instanceAi.previewTabBar.expand',
+	),
+);
+
+function getTabListElement() {
+	const tabList = tabListRef.value;
+	if (tabList instanceof HTMLElement) return tabList;
+	return (tabList as { $el?: HTMLElement } | null)?.$el ?? null;
+}
+
+function scrollTabIntoView(tabId: string) {
+	const tabList = getTabListElement();
+	if (!tabList) return;
+
+	const activeTab = Array.from(tabList.querySelectorAll<HTMLElement>('[data-tab-id]')).find(
+		(tab) => tab.dataset.tabId === tabId,
+	);
+	if (!activeTab) return;
+
+	const tabLeft = activeTab.offsetLeft;
+	const tabRight = tabLeft + activeTab.offsetWidth;
+	const visibleLeft = tabList.scrollLeft;
+	const visibleRight = visibleLeft + tabList.clientWidth;
+
+	const nextScrollLeft =
+		tabLeft < visibleLeft
+			? tabLeft
+			: tabRight > visibleRight
+				? tabRight - tabList.clientWidth
+				: undefined;
+
+	if (nextScrollLeft === undefined) return;
+	if (typeof tabList.scrollTo === 'function') {
+		tabList.scrollTo({ left: nextScrollLeft, behavior: 'smooth' });
+	} else {
+		tabList.scrollLeft = nextScrollLeft;
+	}
+}
 
 // Bring the active tab into view when the selection changes (e.g. auto-switch
-// on execution). scrollIntoView walks up to the nearest scroll container.
+// on execution), without scrolling any outer app containers.
 watch(
 	() => props.activeTabId,
 	(tabId) => {
 		if (!tabId) return;
 		void nextTick(() => {
-			const el = document.querySelector<HTMLElement>(`[data-tab-id="${tabId}"]`);
-			el?.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
+			scrollTabIntoView(tabId);
 		});
 	},
 );
@@ -68,15 +117,18 @@ async function handleCopyLink(tab: ArtifactTab) {
 <template>
 	<div :class="$style.header">
 		<N8nIconButton
-			icon="chevrons-right"
+			v-if="previewToggleLabel"
+			icon="panel-right"
 			variant="ghost"
 			size="medium"
-			:aria-label="i18n.baseText('instanceAi.previewTabBar.collapse')"
-			:title="i18n.baseText('instanceAi.previewTabBar.collapse')"
-			data-test-id="instance-ai-preview-close"
-			@click="emit('close')"
+			:aria-label="previewToggleLabel"
+			:title="previewToggleLabel"
+			:aria-pressed="true"
+			data-test-id="instance-ai-artifacts-preview-toggle"
+			@click="emit('togglePreview')"
 		/>
 		<TabsList
+			ref="tabListRef"
 			:aria-label="i18n.baseText('instanceAi.artifactsPanel.title')"
 			:class="$style.tabList"
 		>
@@ -104,6 +156,15 @@ async function handleCopyLink(tab: ArtifactTab) {
 				</ContextMenuPortal>
 			</ContextMenuRoot>
 		</TabsList>
+		<N8nIconButton
+			:icon="isExpanded ? 'minimize-2' : 'maximize-2'"
+			variant="ghost"
+			size="medium"
+			:aria-label="sizeToggleLabel"
+			:title="sizeToggleLabel"
+			data-test-id="instance-ai-preview-expand-toggle"
+			@click="emit('toggleExpanded')"
+		/>
 	</div>
 </template>
 
@@ -139,16 +200,18 @@ async function handleCopyLink(tab: ArtifactTab) {
 
 .header {
 	flex-shrink: 0;
+	height: 44px;
 	display: flex;
 	align-items: center;
 	gap: var(--spacing--4xs);
-	padding-left: var(--spacing--4xs);
+	padding: 0 var(--spacing--3xs) 0 var(--spacing--4xs);
 	border-bottom: var(--border);
 }
 
 .tabList {
 	flex: 1 1 0;
 	min-width: 0;
+	height: 100%;
 	display: flex;
 	overflow-x: auto;
 	scrollbar-width: none;
@@ -176,7 +239,7 @@ async function handleCopyLink(tab: ArtifactTab) {
 	background-color: transparent;
 	border: none;
 	font-size: var(--font-size--2xs);
-	padding: var(--spacing--sm) var(--spacing--xs);
+	padding: 0 var(--spacing--xs);
 	cursor: pointer;
 
 	&:hover {
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiViewHeader.vue b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiViewHeader.vue
index f9314048be0..a245cf88990 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiViewHeader.vue
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/components/InstanceAiViewHeader.vue
@@ -1,27 +1,20 @@
 <script lang="ts" setup>
 import { computed } from 'vue';
-import { useRouter } from 'vue-router';
 import { N8nCallout, N8nIconButton, N8nTooltip, TOOLTIP_DELAY_MS } from '@n8n/design-system';
 import { useI18n } from '@n8n/i18n';
 import { useSourceControlStore } from '@/features/integrations/sourceControl.ee/sourceControl.store';
 import { usePageRedirectionHelper } from '@/app/composables/usePageRedirectionHelper';
 import { useInstanceAiStore } from '../instanceAi.store';
 import { useSidebarState } from '../instanceAiLayout';
-import { INSTANCE_AI_SETTINGS_VIEW } from '../constants';
 import CreditsSettingsDropdown from '@/features/ai/assistant/components/Agent/CreditsSettingsDropdown.vue';
 
 const store = useInstanceAiStore();
 const sourceControlStore = useSourceControlStore();
 const i18n = useI18n();
-const router = useRouter();
 const sidebar = useSidebarState();
 const { goToUpgrade } = usePageRedirectionHelper();
 
 const isReadOnlyEnvironment = computed(() => sourceControlStore.preferences.branchReadOnly);
-
-function goToSettings() {
-	void router.push({ name: INSTANCE_AI_SETTINGS_VIEW });
-}
 </script>
 
 <template>
@@ -54,14 +47,6 @@ function goToSettings() {
 				:is-low-credits="store.isLowCredits"
 				@upgrade-click="goToUpgrade('instance-ai', 'upgrade-instance-ai')"
 			/>
-			<N8nIconButton
-				icon="cog"
-				variant="ghost"
-				size="small"
-				icon-size="large"
-				data-test-id="instance-ai-settings-button"
-				@click="goToSettings"
-			/>
 			<slot name="actions" />
 		</div>
 	</div>
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/instanceAiLayout.ts b/packages/frontend/editor-ui/src/features/ai/instanceAi/instanceAiLayout.ts
index ca80e29a5a5..dde74058b45 100644
--- a/packages/frontend/editor-ui/src/features/ai/instanceAi/instanceAiLayout.ts
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/instanceAiLayout.ts
@@ -8,6 +8,7 @@ import { inject } from 'vue';
  */
 export interface SidebarState {
 	collapsed: Ref<boolean>;
+	width?: Ref<number>;
 	toggle: () => void;
 }
 
diff --git a/packages/frontend/editor-ui/src/features/ai/instanceAi/useTransitionGate.ts b/packages/frontend/editor-ui/src/features/ai/instanceAi/useTransitionGate.ts
new file mode 100644
index 00000000000..712b6c2b639
--- /dev/null
+++ b/packages/frontend/editor-ui/src/features/ai/instanceAi/useTransitionGate.ts
@@ -0,0 +1,34 @@
+import { nextTick, ref } from 'vue';
+
+export function useTransitionGate(options: { isBlocked?: () => boolean } = {}) {
+	const isEnabled = ref(false);
+	let renderToken = 0;
+
+	function enableAfterStableRender() {
+		const currentRenderToken = ++renderToken;
+		void nextTick(() => {
+			void nextTick(() => {
+				if (currentRenderToken === renderToken && !(options.isBlocked?.() ?? false)) {
+					isEnabled.value = true;
+				}
+			});
+		});
+	}
+
+	function suppress() {
+		renderToken += 1;
+		isEnabled.value = false;
+	}
+
+	function suppressUntilStableRender() {
+		isEnabled.value = false;
+		enableAfterStableRender();
+	}
+
+	return {
+		isEnabled,
+		enableAfterStableRender,
+		suppress,
+		suppressUntilStableRender,
+	};
+}
diff --git a/packages/frontend/editor-ui/src/features/ai/mcpAccess/module.descriptor.ts b/packages/frontend/editor-ui/src/features/ai/mcpAccess/module.descriptor.ts
index 04ea1213808..8ae03eae64e 100644
--- a/packages/frontend/editor-ui/src/features/ai/mcpAccess/module.descriptor.ts
+++ b/packages/frontend/editor-ui/src/features/ai/mcpAccess/module.descriptor.ts
@@ -1,5 +1,6 @@
 import { useI18n } from '@n8n/i18n';
 import { type FrontendModuleDescription } from '@/app/moduleInitializer/module.types';
+import { SURFACE_MCP_TO_NEW_CLOUD_USERS_MODALS } from '@/experiments/surfaceMcpToNewCloudUsers/modals';
 import {
 	MCP_CONNECT_WORKFLOWS_MODAL_KEY,
 	MCP_SETTINGS_VIEW,
@@ -50,5 +51,6 @@ export const MCPModule: FrontendModuleDescription = {
 			component: async () => await import('./modals/MCPConnectWorkflowsModal.vue'),
 			initialState: { open: false },
 		},
+		...SURFACE_MCP_TO_NEW_CLOUD_USERS_MODALS,
 	],
 };
diff --git a/packages/frontend/editor-ui/src/features/core/dataTable/components/AddDataTableModal.vue b/packages/frontend/editor-ui/src/features/core/dataTable/components/AddDataTableModal.vue
index 786f636d3a1..52908e99a6e 100644
--- a/packages/frontend/editor-ui/src/features/core/dataTable/components/AddDataTableModal.vue
+++ b/packages/frontend/editor-ui/src/features/core/dataTable/components/AddDataTableModal.vue
@@ -199,9 +199,34 @@ const reset = (clearTableName = false) => {
 	creationMode.value = 'select';
 };
 
-const handleFileChange = (uploadFile: UploadFile) => {
-	if (uploadFile.raw) {
-		selectedFile.value = uploadFile.raw;
+const deriveNameFromFileName = (fileName: string): string => {
+	return fileName
+		.replace(/\.csv$/i, '')
+		.replace(/[^a-zA-Z0-9]+/g, ' ')
+		.trim()
+		.slice(0, 128)
+		.trim();
+};
+
+const handleFileChange = async (uploadFile: UploadFile) => {
+	if (!uploadFile.raw) return;
+	const file = uploadFile.raw;
+	selectedFile.value = file;
+	if (dataTableName.value) return;
+
+	const baseName = deriveNameFromFileName(file.name);
+	if (!baseName) return;
+
+	const projectId = route.params.projectId as string;
+	try {
+		const suggested = await dataTableStore.findAvailableDataTableName(baseName, projectId);
+		if (selectedFile.value === file && !dataTableName.value) {
+			dataTableName.value = suggested;
+		}
+	} catch {
+		if (selectedFile.value === file && !dataTableName.value) {
+			dataTableName.value = baseName;
+		}
 	}
 };
 
@@ -231,11 +256,6 @@ const uploadFile = async () => {
 				csvColumnName: col.name,
 			};
 		});
-
-		if (!dataTableName.value) {
-			const fileName = selectedFile.value.name.replace(/\.csv$/i, '');
-			dataTableName.value = fileName;
-		}
 	} catch (error) {
 		toast.showError(error, i18n.baseText('dataTable.upload.error'));
 		reset();
diff --git a/packages/frontend/editor-ui/src/features/core/dataTable/dataTable.store.ts b/packages/frontend/editor-ui/src/features/core/dataTable/dataTable.store.ts
index c146fb72e92..82037c28eb5 100644
--- a/packages/frontend/editor-ui/src/features/core/dataTable/dataTable.store.ts
+++ b/packages/frontend/editor-ui/src/features/core/dataTable/dataTable.store.ts
@@ -128,6 +128,47 @@ export const useDataTableStore = defineStore(DATA_TABLE_STORE, () => {
 		return await uploadCsvFileApi(rootStore.restApiContext, file, hasHeaders);
 	};
 
+	const findAvailableDataTableName = async (
+		baseName: string,
+		projectId: string,
+	): Promise<string> => {
+		const MAX_NAME_LENGTH = 128;
+		const PAGE_SIZE = 250;
+		const trimmed = baseName.trim().slice(0, MAX_NAME_LENGTH).trim();
+		if (!trimmed || !projectId) return trimmed;
+
+		const existingNames = new Set<string>();
+		let skip = 0;
+		while (true) {
+			const response = await fetchDataTablesApi(
+				rootStore.restApiContext,
+				projectId,
+				{ skip, take: PAGE_SIZE },
+				{ name: trimmed },
+			);
+			for (const t of response.data) {
+				existingNames.add(t.name.toLowerCase());
+			}
+			skip += response.data.length;
+			if (response.data.length < PAGE_SIZE || skip >= response.count) break;
+		}
+
+		if (!existingNames.has(trimmed.toLowerCase())) return trimmed;
+
+		const buildCandidate = (n: number): string => {
+			const suffix = ` ${n}`;
+			const maxBaseLen = MAX_NAME_LENGTH - suffix.length;
+			const base = trimmed.length > maxBaseLen ? trimmed.slice(0, maxBaseLen).trim() : trimmed;
+			return `${base}${suffix}`;
+		};
+
+		let n = 2;
+		while (existingNames.has(buildCandidate(n).toLowerCase())) {
+			n++;
+		}
+		return buildCandidate(n);
+	};
+
 	const importCsvToDataTable = async (dataTableId: string, projectId: string, fileId: string) => {
 		return await importCsvToDataTableApi(rootStore.restApiContext, dataTableId, projectId, fileId);
 	};
@@ -385,6 +426,7 @@ export const useDataTableStore = defineStore(DATA_TABLE_STORE, () => {
 		maxSizeMB,
 		createDataTable,
 		uploadCsvFile,
+		findAvailableDataTableName,
 		importCsvToDataTable,
 		deleteDataTable,
 		updateDataTable,
diff --git a/packages/nodes-base/credentials/common/aws/system-credentials-utils.test.ts b/packages/nodes-base/credentials/common/aws/system-credentials-utils.test.ts
index 2ac9d5e3fd5..b1881956156 100644
--- a/packages/nodes-base/credentials/common/aws/system-credentials-utils.test.ts
+++ b/packages/nodes-base/credentials/common/aws/system-credentials-utils.test.ts
@@ -811,4 +811,154 @@ describe('system-credentials-utils', () => {
 			expect(result).toBeNull();
 		});
 	});
+
+	describe('getRoleForServiceAccountCredentials', () => {
+		it('should return null when AWS_ROLE_ARN or AWS_WEB_IDENTITY_TOKEN_FILE is not available via envGetter', async () => {
+			mockEnvGetter.mockImplementation(() => undefined);
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toBeNull();
+			expect(mockEnvGetter).toHaveBeenCalledWith('AWS_ROLE_ARN');
+			expect(mockEnvGetter).toHaveBeenCalledWith('AWS_WEB_IDENTITY_TOKEN_FILE');
+		});
+
+		it('should fetch credentials successfully with role and token file from envGetter', async () => {
+			mockEnvGetter.mockImplementation((key: string) => {
+				switch (key) {
+					case 'AWS_ROLE_ARN':
+						return 'arn:aws:iam::123456789012:role/test-role';
+					case 'AWS_WEB_IDENTITY_TOKEN_FILE':
+						return '/tmp/token';
+					default:
+						return undefined;
+				}
+			});
+
+			mockReadFile.mockResolvedValue('test-web-identity-token');
+
+			const mockCredentials = {
+				AssumeRoleWithWebIdentityResponse: {
+					AssumeRoleWithWebIdentityResult: {
+						Credentials: {
+							AccessKeyId: 'test-access-key',
+							SecretAccessKey: 'test-secret-key',
+							SessionToken: 'test-token',
+						},
+					},
+				},
+			};
+
+			(global.fetch as jest.Mock).mockResolvedValue({
+				ok: true,
+				json: jest.fn().mockResolvedValue(mockCredentials),
+			});
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toEqual({
+				accessKeyId: 'test-access-key',
+				secretAccessKey: 'test-secret-key',
+				sessionToken: 'test-token',
+			});
+
+			expect(mockReadFile).toHaveBeenCalledWith('/tmp/token', 'utf8');
+			expect(global.fetch).toHaveBeenCalledWith(
+				'https://sts.amazonaws.com',
+				expect.objectContaining({
+					method: 'POST',
+					headers: {
+						'User-Agent': 'n8n-aws-credential',
+						'Content-Type': 'application/x-www-form-urlencoded',
+						Accept: 'application/json',
+					},
+					body: expect.stringContaining('Action=AssumeRoleWithWebIdentity'),
+				}),
+			);
+			expect((global.fetch as jest.Mock).mock.calls[0][1].body).toContain(
+				'RoleArn=arn%3Aaws%3Aiam%3A%3A123456789012%3Arole%2Ftest-role',
+			);
+		});
+
+		it('should return null when fetch fails', async () => {
+			mockEnvGetter.mockImplementation((key: string) => {
+				switch (key) {
+					case 'AWS_ROLE_ARN':
+						return 'arn:aws:iam::123456789012:role/test-role';
+					case 'AWS_WEB_IDENTITY_TOKEN_FILE':
+						return '/tmp/token';
+					default:
+						return undefined;
+				}
+			});
+			mockReadFile.mockResolvedValue('test-web-identity-token');
+			(global.fetch as jest.Mock).mockResolvedValue({ ok: false });
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toBeNull();
+		});
+
+		it('should return null when credentials are incomplete', async () => {
+			mockEnvGetter.mockImplementation((key: string) => {
+				switch (key) {
+					case 'AWS_ROLE_ARN':
+						return 'arn:aws:iam::123456789012:role/test-role';
+					case 'AWS_WEB_IDENTITY_TOKEN_FILE':
+						return '/tmp/token';
+					default:
+						return undefined;
+				}
+			});
+			mockReadFile.mockResolvedValue('test-web-identity-token');
+			const incomplete = {
+				AssumeRoleWithWebIdentityResponse: {
+					AssumeRoleWithWebIdentityResult: {
+						Credentials: {
+							AccessKeyId: 'test-access-key',
+						},
+					},
+				},
+			};
+			(global.fetch as jest.Mock).mockResolvedValue({
+				ok: true,
+				json: jest.fn().mockResolvedValue(incomplete),
+			});
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toBeNull();
+		});
+
+		it('should return null when fetch throws an error', async () => {
+			mockEnvGetter.mockImplementation((key: string) => {
+				switch (key) {
+					case 'AWS_ROLE_ARN':
+						return 'arn:aws:iam::123456789012:role/test-role';
+					case 'AWS_WEB_IDENTITY_TOKEN_FILE':
+						return '/tmp/token';
+					default:
+						return undefined;
+				}
+			});
+			mockReadFile.mockResolvedValue('test-web-identity-token');
+			(global.fetch as jest.Mock).mockRejectedValue(new Error('Network error'));
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toBeNull();
+		});
+
+		it('should return null when token file is empty', async () => {
+			mockEnvGetter.mockImplementation((key: string) => {
+				switch (key) {
+					case 'AWS_ROLE_ARN':
+						return 'arn:aws:iam::123456789012:role/test-role';
+					case 'AWS_WEB_IDENTITY_TOKEN_FILE':
+						return '/tmp/token';
+					default:
+						return undefined;
+				}
+			});
+			mockReadFile.mockResolvedValue('');
+
+			const result = await credentialsResolver.roleForServiceAccount();
+			expect(result).toBeNull();
+		});
+	});
 });
diff --git a/packages/nodes-base/credentials/common/aws/system-credentials-utils.ts b/packages/nodes-base/credentials/common/aws/system-credentials-utils.ts
index c821b88b0e3..cefbe427257 100644
--- a/packages/nodes-base/credentials/common/aws/system-credentials-utils.ts
+++ b/packages/nodes-base/credentials/common/aws/system-credentials-utils.ts
@@ -3,7 +3,12 @@ import { Container } from '@n8n/di';
 import { ApplicationError } from 'n8n-workflow';
 import { readFile } from 'fs/promises';
 
-type Resolvers = 'environment' | 'podIdentity' | 'containerMetadata' | 'instanceMetadata';
+type Resolvers =
+	| 'environment'
+	| 'roleForServiceAccount'
+	| 'podIdentity'
+	| 'containerMetadata'
+	| 'instanceMetadata';
 type ReturnData = {
 	accessKeyId: string;
 	secretAccessKey: string;
@@ -17,15 +22,17 @@ export const credentialsResolver: Record<Resolvers, () => Promise<ReturnData | n
 	instanceMetadata: getInstanceMetadataCredentials,
 	containerMetadata: getContainerMetadataCredentials,
 	podIdentity: getPodIdentityCredentials,
+	roleForServiceAccount: getRoleForServiceAccountCredentials,
 };
 
 /**
  * Retrieves AWS credentials from various system sources following the AWS credential chain.
  * Attempts to get credentials in the following order:
  * 1. Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN)
- * 2. EKS Pod Identity (AWS_CONTAINER_CREDENTIALS_FULL_URI)
- * 3. ECS/Fargate container metadata (AWS_CONTAINER_CREDENTIALS_RELATIVE_URI)
- * 4. EC2 instance metadata service
+ * 2. IAM Role for Service Account (AWS_ROLE_ARN + AWS_WEB_IDENTITY_TOKEN_FILE)
+ * 3. EKS Pod Identity (AWS_CONTAINER_CREDENTIALS_FULL_URI)
+ * 4. ECS/Fargate container metadata (AWS_CONTAINER_CREDENTIALS_RELATIVE_URI)
+ * 5. EC2 instance metadata service
  */
 export async function getSystemCredentials() {
 	if (!Container.get(SecurityConfig).awsSystemCredentialsAccess) {
@@ -36,6 +43,7 @@ export async function getSystemCredentials() {
 
 	const resolveOrder: Resolvers[] = [
 		'environment',
+		'roleForServiceAccount',
 		'podIdentity',
 		'containerMetadata',
 		'instanceMetadata',
@@ -267,3 +275,74 @@ async function getPodIdentityCredentials() {
 		return null;
 	}
 }
+
+/**
+ * Retrieves AWS credentials by assuming a role via OIDC web identity (IRSA).
+ * Used when running in EKS with IAM Roles for Service Accounts configured.
+ * Reads the OIDC token from the file at AWS_WEB_IDENTITY_TOKEN_FILE and calls
+ * STS AssumeRoleWithWebIdentity to exchange it for temporary credentials.
+ *
+ * @returns Promise resolving to credentials object or null if IRSA is not configured
+ *
+ * @see {@link https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html IRSA}
+ * @see {@link https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html STS API}
+ * @see {@link https://github.com/aws/aws-sdk-js-v3/blob/main/packages-internal/credential-provider-web-identity/src/fromWebToken.ts AWS SDK v3 implementation}
+ */
+async function getRoleForServiceAccountCredentials() {
+	const iamRole = envGetter('AWS_ROLE_ARN');
+	const webIdentityTokenFile = envGetter('AWS_WEB_IDENTITY_TOKEN_FILE');
+
+	try {
+		if (!iamRole || !webIdentityTokenFile) {
+			return null;
+		}
+
+		const token = (await readFile(webIdentityTokenFile, 'utf8')).trim();
+		if (!token) {
+			return null;
+		}
+
+		const headers: Record<string, string> = {
+			'User-Agent': 'n8n-aws-credential',
+			'Content-Type': 'application/x-www-form-urlencoded',
+			Accept: 'application/json',
+		};
+
+		const body = new URLSearchParams({
+			Action: 'AssumeRoleWithWebIdentity',
+			RoleArn: iamRole,
+			RoleSessionName: 'n8n-web-identity-session',
+			WebIdentityToken: token,
+			Version: '2011-06-15',
+		});
+
+		// Global STS endpoint; China/GovCloud regions unsupported until region is passed through getSystemCredentials
+		// STS supports Accept: application/json (undocumented) to return JSON instead of XML.
+		const credentialsResponse = await fetch('https://sts.amazonaws.com', {
+			method: 'POST',
+			headers,
+			body: body.toString(),
+			signal: AbortSignal.timeout(2000),
+		});
+
+		if (!credentialsResponse.ok) {
+			return null;
+		}
+
+		const data = await credentialsResponse.json();
+		const credentialsData =
+			data?.AssumeRoleWithWebIdentityResponse?.AssumeRoleWithWebIdentityResult?.Credentials;
+
+		if (!credentialsData || !credentialsData.AccessKeyId || !credentialsData.SecretAccessKey) {
+			return null;
+		}
+
+		return {
+			accessKeyId: credentialsData.AccessKeyId,
+			secretAccessKey: credentialsData.SecretAccessKey,
+			sessionToken: credentialsData.SessionToken,
+		};
+	} catch (error) {
+		return null;
+	}
+}
diff --git a/packages/nodes-base/nodes/Git/Git.node.ts b/packages/nodes-base/nodes/Git/Git.node.ts
index 7978cdc49ce..e2bd7d72ca9 100644
--- a/packages/nodes-base/nodes/Git/Git.node.ts
+++ b/packages/nodes-base/nodes/Git/Git.node.ts
@@ -343,11 +343,12 @@ export class Git implements INodeType {
 					...(!enableHooks && { unsafe: { allowUnsafeHooksPath: true } }),
 				};
 
-				const git: SimpleGit = simpleGit(gitOptions)
-					// Tell git not to ask for any information via the terminal like for
-					// example the username. As nobody will be able to answer it would
-					// n8n keep on waiting forever.
-					.env('GIT_TERMINAL_PROMPT', '0');
+				const cleanEnv = Object.create(null) as Record<string, unknown>;
+				// Tell git not to ask for any information via the terminal like for
+				// example the username. As nobody will be able to answer it would
+				// n8n keep on waiting forever.
+				cleanEnv['GIT_TERMINAL_PROMPT'] = '0';
+				const git: SimpleGit = simpleGit(gitOptions).env(cleanEnv);
 
 				if (operation === 'add') {
 					// ----------------------------------
diff --git a/packages/nodes-base/nodes/Git/test/Git.node.test.ts b/packages/nodes-base/nodes/Git/test/Git.node.test.ts
index 87c81c6b637..5a4ec7c413f 100644
--- a/packages/nodes-base/nodes/Git/test/Git.node.test.ts
+++ b/packages/nodes-base/nodes/Git/test/Git.node.test.ts
@@ -61,6 +61,32 @@ describe('Git Node', () => {
 		jest.clearAllMocks();
 	});
 
+	describe('Environment validation', () => {
+		it('should not include invalid inherited environment keys in simple-git env', async () => {
+			const inheritedEnvKey = 'N8N_TEST_INVALID_ENV_KEY';
+			(Object.prototype as Record<string, unknown>)[inheritedEnvKey] = 'ignored';
+
+			mockExecuteFunctions.getNodeParameter
+				.mockReturnValueOnce('log')
+				.mockReturnValueOnce('/repo')
+				.mockReturnValueOnce({});
+
+			mockGit.log.mockResolvedValueOnce({ all: [] } as any);
+
+			try {
+				await gitNode.execute.call(mockExecuteFunctions);
+			} finally {
+				delete (Object.prototype as Record<string, unknown>)[inheritedEnvKey];
+			}
+
+			expect(mockGit.env).toHaveBeenCalledTimes(1);
+			const envArg = mockGit.env.mock.calls[0][0] as Record<string, string>;
+			expect(Object.prototype.hasOwnProperty.call(envArg, inheritedEnvKey)).toBe(false);
+			expect(envArg[inheritedEnvKey]).toBeUndefined();
+			expect(envArg.GIT_TERMINAL_PROMPT).toBe('0');
+		});
+	});
+
 	describe('Branch switching', () => {
 		const mockNodeParameters = (params: Record<string, unknown>) => {
 			mockExecuteFunctions.getNodeParameter.mockImplementation(
diff --git a/packages/nodes-base/nodes/HttpRequest/V3/Description.ts b/packages/nodes-base/nodes/HttpRequest/V3/Description.ts
index cb3a4ad0b0c..d87764c3b7a 100644
--- a/packages/nodes-base/nodes/HttpRequest/V3/Description.ts
+++ b/packages/nodes-base/nodes/HttpRequest/V3/Description.ts
@@ -117,6 +117,14 @@ export const mainProperties: INodeProperties[] = [
 				authentication: ['genericCredentialType'],
 			},
 		},
+		builderHint: {
+			propertyHint: `Pick by how the API authenticates, not by what the user calls it:
+- "Authorization: Bearer <token>" → httpBearerAuth (single token field, best UX). Use this for OpenAI, Anthropic, GitHub PATs, Stripe, Notion, and any service whose docs say "Bearer".
+- Custom header like X-API-Key, apikey, X-Auth-Token, or non-Bearer Authorization schemes → httpHeaderAuth (user must enter the header name and/or full value).
+- API key in the query string (?api_key=...) → httpQueryAuth.
+- username + password → httpBasicAuth.
+A user saying "API key" or "header auth" usually means httpBearerAuth only when the docs use the Authorization: Bearer <token> scheme. Use httpHeaderAuth for custom header names or non-Bearer Authorization schemes where the full header value/prefix must be user-controlled.`,
+		},
 	},
 	{
 		displayName: 'SSL Certificates',
diff --git a/packages/nodes-base/nodes/HttpRequest/V3/HttpRequestV3.node.ts b/packages/nodes-base/nodes/HttpRequest/V3/HttpRequestV3.node.ts
index 50bb4ded2dc..67ccfa831c7 100644
--- a/packages/nodes-base/nodes/HttpRequest/V3/HttpRequestV3.node.ts
+++ b/packages/nodes-base/nodes/HttpRequest/V3/HttpRequestV3.node.ts
@@ -24,6 +24,7 @@ import {
 	removeCircularRefs,
 	sleep,
 	ensureError,
+	setSafeObjectProperty,
 } from 'n8n-workflow';
 import type { Readable } from 'stream';
 
@@ -60,6 +61,10 @@ function isEmptyResponseBody(body: unknown): body is string {
 	return typeof body === 'string' && body.trim().length === 0;
 }
 
+function isPaginationRequestType(value: string): value is 'body' | 'headers' | 'qs' {
+	return value === 'body' || value === 'headers' || value === 'qs';
+}
+
 export class HttpRequestV3 implements INodeType {
 	description: INodeTypeDescription;
 
@@ -639,13 +644,12 @@ export class HttpRequestV3 implements INodeType {
 
 					const paginationData: PaginationOptions = {
 						continue: continueExpression,
-						request: {},
+						request: Object.create(null) as Record<string, unknown>,
 						requestInterval: pagination.requestInterval,
 					};
 
 					if (pagination.paginationMode === 'updateAParameterInEachRequest') {
 						// Iterate over all parameters and add them to the request
-						paginationData.request = {};
 						const { parameters } = pagination.parameters;
 						if (
 							parameters.length === 1 &&
@@ -658,9 +662,6 @@ export class HttpRequestV3 implements INodeType {
 							);
 						}
 						pagination.parameters.parameters.forEach((parameter, index) => {
-							if (!paginationData.request[parameter.type]) {
-								paginationData.request[parameter.type] = {};
-							}
 							const parameterName = parameter.name;
 							if (parameterName === '') {
 								throw new NodeOperationError(
@@ -668,6 +669,18 @@ export class HttpRequestV3 implements INodeType {
 									`Parameter name must be set for parameter [${index + 1}] in pagination settings`,
 								);
 							}
+
+							if (!isPaginationRequestType(parameter.type)) {
+								throw new NodeOperationError(
+									this.getNode(),
+									`Parameter type must be one of: body, headers, qs for parameter [${
+										index + 1
+									}] in pagination settings`,
+								);
+							}
+
+							paginationData.request[parameter.type] ??= Object.create(null);
+
 							const parameterValue = parameter.value;
 							if (parameterValue === '') {
 								throw new NodeOperationError(
@@ -677,7 +690,12 @@ export class HttpRequestV3 implements INodeType {
 									}] in pagination settings, omitting it will result in an infinite loop`,
 								);
 							}
-							paginationData.request[parameter.type]![parameterName] = parameterValue;
+
+							setSafeObjectProperty(
+								paginationData.request[parameter.type]!,
+								parameterName,
+								parameterValue,
+							);
 						});
 					} else if (pagination.paginationMode === 'responseContainsNextURL') {
 						paginationData.request.url = pagination.nextURL;
diff --git a/packages/nodes-base/nodes/HttpRequest/test/node/HttpRequestV3.test.ts b/packages/nodes-base/nodes/HttpRequest/test/node/HttpRequestV3.test.ts
index 582b63e585e..115332e4b2e 100644
--- a/packages/nodes-base/nodes/HttpRequest/test/node/HttpRequestV3.test.ts
+++ b/packages/nodes-base/nodes/HttpRequest/test/node/HttpRequestV3.test.ts
@@ -607,4 +607,156 @@ describe('HttpRequestV3', () => {
 			);
 		});
 	});
+
+	describe('Pagination parameter validation', () => {
+		it('should keep valid pagination parameters and ignore invalid parameter names', async () => {
+			const paginationTestOptions = {
+				...options,
+				response: {
+					response: {
+						neverError: false,
+						responseFormat: 'json',
+						fullResponse: false,
+						outputPropertyName: 'data',
+					},
+				},
+			};
+			(executeFunctions.getInputData as jest.Mock).mockReturnValue([{ json: {} }]);
+			(executeFunctions.getNodeParameter as jest.Mock).mockImplementation(
+				(paramName: string, _itemIndex: number, defaultValue: unknown) => {
+					switch (paramName) {
+						case 'method':
+							return 'GET';
+						case 'url':
+							return baseUrl;
+						case 'authentication':
+							return 'none';
+						case 'options':
+							return paginationTestOptions;
+						case 'options.pagination.pagination':
+							return {
+								paginationMode: 'updateAParameterInEachRequest',
+								parameters: {
+									parameters: [
+										{
+											type: 'qs',
+											// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+											name: 'page',
+											value: '1',
+										},
+										{
+											type: 'qs',
+											name: 'constructor',
+											value: 'ignored',
+										},
+									],
+								},
+								paginationCompleteWhen: 'responseIsEmpty',
+								statusCodesWhenComplete: '',
+								completeExpression: '',
+								limitPagesFetched: false,
+								maxRequests: 10,
+								requestInterval: 0,
+							};
+						case 'options.response.response.responseFormat':
+							return 'json';
+						default:
+							return defaultValue;
+					}
+				},
+			);
+			(executeFunctions.helpers.requestWithAuthenticationPaginated as jest.Mock).mockResolvedValue([
+				{
+					headers: { 'content-type': 'application/json' },
+					body: { success: true },
+					statusCode: 200,
+				},
+			]);
+
+			const result = await node.execute.call(executeFunctions);
+
+			expect(result).toEqual([[{ json: { success: true }, pairedItem: { item: 0 } }]]);
+			expect(executeFunctions.helpers.requestWithAuthenticationPaginated).toHaveBeenCalledTimes(1);
+			const paginationData = (
+				executeFunctions.helpers.requestWithAuthenticationPaginated as jest.Mock
+			).mock.calls[0][2] as {
+				request: {
+					qs: Record<string, unknown>;
+				};
+			};
+			expect(paginationData.request.qs).toEqual({ page: '1' });
+			expect(Object.prototype.hasOwnProperty.call(paginationData.request.qs, 'constructor')).toBe(
+				false,
+			);
+		});
+
+		it('should reject invalid pagination parameter type values', async () => {
+			const paginationTestOptions = {
+				...options,
+				response: {
+					response: {
+						neverError: false,
+						responseFormat: 'json',
+						fullResponse: false,
+						outputPropertyName: 'data',
+					},
+				},
+			};
+
+			(executeFunctions.getInputData as jest.Mock).mockReturnValue([{ json: {} }]);
+			(executeFunctions.helpers.requestWithAuthenticationPaginated as jest.Mock).mockResolvedValue([
+				{
+					headers: { 'content-type': 'application/json' },
+					body: { success: true },
+					statusCode: 200,
+				},
+			]);
+			(executeFunctions.helpers.request as jest.Mock).mockResolvedValue({
+				headers: { 'content-type': 'application/json' },
+				body: Buffer.from(JSON.stringify({ success: true })),
+			});
+
+			(executeFunctions.getNodeParameter as jest.Mock).mockImplementation(
+				(paramName: string, _itemIndex: number, defaultValue: unknown) => {
+					switch (paramName) {
+						case 'method':
+							return 'GET';
+						case 'url':
+							return baseUrl;
+						case 'authentication':
+							return 'none';
+						case 'options':
+							return paginationTestOptions;
+						case 'options.pagination.pagination':
+							return {
+								paginationMode: 'updateAParameterInEachRequest',
+								parameters: {
+									parameters: [
+										{
+											type: '__proto__' as unknown as 'qs',
+											// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+											name: 'page',
+											value: '1',
+										},
+									],
+								},
+								paginationCompleteWhen: 'responseIsEmpty',
+								statusCodesWhenComplete: '',
+								completeExpression: '',
+								limitPagesFetched: false,
+								maxRequests: 10,
+								requestInterval: 0,
+							};
+						default:
+							return defaultValue;
+					}
+				},
+			);
+
+			await expect(node.execute.call(executeFunctions)).rejects.toThrow(
+				'Parameter type must be one of: body, headers, qs for parameter [1] in pagination settings',
+			);
+			expect(executeFunctions.helpers.requestWithAuthenticationPaginated).not.toHaveBeenCalled();
+		});
+	});
 });
diff --git a/packages/nodes-base/nodes/Xml/Xml.node.ts b/packages/nodes-base/nodes/Xml/Xml.node.ts
index 76322b46bec..b098dbc6c9f 100644
--- a/packages/nodes-base/nodes/Xml/Xml.node.ts
+++ b/packages/nodes-base/nodes/Xml/Xml.node.ts
@@ -236,19 +236,23 @@ export class Xml implements INodeType {
 		const options = this.getNodeParameter('options', 0, {});
 
 		const forbiddenKeys = ['__proto__', 'constructor', 'prototype'];
-		const attrkey = String(options.attrkey ?? '');
-		const charkey = String(options.charkey ?? '');
-		if (forbiddenKeys.includes(attrkey)) {
-			throw new NodeOperationError(
-				this.getNode(),
-				`The "Attribute Key" option value "${attrkey}" is not allowed`,
-			);
+		if (options.attrkey !== undefined) {
+			options.attrkey = String(options.attrkey);
+			if (forbiddenKeys.includes(options.attrkey)) {
+				throw new NodeOperationError(
+					this.getNode(),
+					`The "Attribute Key" option value "${options.attrkey}" is not allowed`,
+				);
+			}
 		}
-		if (forbiddenKeys.includes(charkey)) {
-			throw new NodeOperationError(
-				this.getNode(),
-				`The "Character Key" option value "${charkey}" is not allowed`,
-			);
+		if (options.charkey !== undefined) {
+			options.charkey = String(options.charkey);
+			if (forbiddenKeys.includes(options.charkey)) {
+				throw new NodeOperationError(
+					this.getNode(),
+					`The "Character Key" option value "${options.charkey}" is not allowed`,
+				);
+			}
 		}
 
 		let item: INodeExecutionData;
diff --git a/packages/nodes-base/nodes/Xml/test/node/Xml.test.ts b/packages/nodes-base/nodes/Xml/test/node/Xml.test.ts
index 0f8cc231d03..5102ed28d02 100644
--- a/packages/nodes-base/nodes/Xml/test/node/Xml.test.ts
+++ b/packages/nodes-base/nodes/Xml/test/node/Xml.test.ts
@@ -130,4 +130,104 @@ describe('Xml Node - options validation', () => {
 			},
 		);
 	});
+
+	describe('default option behaviour', () => {
+		test('should use the parser default attribute key when attrkey option is not set', async () => {
+			setupGetNodeParameter('xmlToJson', { mergeAttrs: false, explicitArray: false });
+			mockExecuteFunctions.getInputData.mockReturnValue([
+				{ json: { data: '<root foo="bar">x</root>' } },
+			]);
+
+			const result = await xmlNode.execute.call(mockExecuteFunctions);
+
+			const parsed = result[0][0].json as { root: Record<string, unknown> };
+			expect(parsed.root).toHaveProperty('$', { foo: 'bar' });
+		});
+
+		test('should use the parser default character key when charkey option is not set', async () => {
+			setupGetNodeParameter('xmlToJson', { mergeAttrs: false, explicitArray: false });
+			mockExecuteFunctions.getInputData.mockReturnValue([
+				{ json: { data: '<root foo="bar">text</root>' } },
+			]);
+
+			const result = await xmlNode.execute.call(mockExecuteFunctions);
+
+			const parsed = result[0][0].json as { root: Record<string, unknown> };
+			expect(parsed.root).toHaveProperty('_', 'text');
+		});
+	});
+
+	describe('attrkey and charkey are coerced to a stable string', () => {
+		test('should forward the coerced attrkey string to the parser in xmlToJson mode', async () => {
+			const statefulAttrkey = (() => {
+				let calls = 0;
+				return {
+					toString: () => (++calls === 1 ? 'safe' : 'changed'),
+				};
+			})();
+
+			setupGetNodeParameter('xmlToJson', {
+				attrkey: statefulAttrkey,
+				mergeAttrs: false,
+				explicitArray: false,
+			});
+			mockExecuteFunctions.getInputData.mockReturnValue([
+				{ json: { data: '<root foo="bar">x</root>' } },
+			]);
+
+			const result = await xmlNode.execute.call(mockExecuteFunctions);
+
+			const parsed = result[0][0].json as { root: Record<string, unknown> };
+			expect(parsed.root).toHaveProperty('safe', { foo: 'bar' });
+			expect(parsed.root).not.toHaveProperty('changed');
+		});
+
+		test('should forward the coerced charkey string to the parser in xmlToJson mode', async () => {
+			const statefulCharkey = (() => {
+				let calls = 0;
+				return {
+					toString: () => (++calls === 1 ? 'safe' : 'changed'),
+				};
+			})();
+
+			setupGetNodeParameter('xmlToJson', {
+				charkey: statefulCharkey,
+				mergeAttrs: false,
+				explicitArray: false,
+			});
+			mockExecuteFunctions.getInputData.mockReturnValue([
+				{ json: { data: '<root foo="bar">text</root>' } },
+			]);
+
+			const result = await xmlNode.execute.call(mockExecuteFunctions);
+
+			const parsed = result[0][0].json as { root: Record<string, unknown> };
+			expect(parsed.root).toHaveProperty('safe', 'text');
+			expect(parsed.root).not.toHaveProperty('changed');
+		});
+
+		test('should forward the coerced attrkey string to the builder in jsonToxml mode', async () => {
+			const statefulAttrkey = (() => {
+				let calls = 0;
+				return {
+					toString: () => (++calls === 1 ? 'safe' : 'changed'),
+				};
+			})();
+
+			setupGetNodeParameter('jsonToxml', {
+				attrkey: statefulAttrkey,
+				headless: true,
+			});
+			mockExecuteFunctions.getInputData.mockReturnValue([
+				{ json: { root: { safe: { foo: 'bar' } } } },
+			]);
+
+			const result = await xmlNode.execute.call(mockExecuteFunctions);
+
+			const xml = (result[0][0].json as { data: string }).data;
+			expect(xml).toContain('foo="bar"');
+			expect(xml).not.toContain('<safe');
+			expect(xml).not.toContain('<changed');
+		});
+	});
 });
diff --git a/packages/nodes-base/nodes/Zendesk/ZendeskTrigger.node.ts b/packages/nodes-base/nodes/Zendesk/ZendeskTrigger.node.ts
index 2514f9854bb..9c9ddba9d42 100644
--- a/packages/nodes-base/nodes/Zendesk/ZendeskTrigger.node.ts
+++ b/packages/nodes-base/nodes/Zendesk/ZendeskTrigger.node.ts
@@ -220,81 +220,63 @@ export class ZendeskTrigger implements INodeType {
 
 	webhookMethods = {
 		default: {
+			/**
+			 * Checks whether the Zendesk webhook and trigger created by this workflow
+			 * still exist. Returns true only when both are confirmed present, which
+			 * prevents unnecessary recreation and avoids the scenario where a failed
+			 * create() call causes clearWebhooks() to delete the Zendesk webhook.
+			 *
+			 * We intentionally do NOT delete triggers owned by other workflows.
+			 * Duplicated n8n workflows share the same webhook URL, so cleaning up
+			 * "unknown" triggers would silently destroy a sibling workflow's setup.
+			 */
 			async checkExists(this: IHookFunctions): Promise<boolean> {
 				const webhookUrl = this.getNodeWebhookUrl('default') as string;
 				const webhookData = this.getWorkflowStaticData('node');
-				const conditions = this.getNodeParameter('conditions') as IDataObject;
 
-				let endpoint = '';
-				const resultAll = [],
-					resultAny = [];
-
-				const conditionsAll = conditions.all as [IDataObject];
-				if (conditionsAll) {
-					for (const conditionAll of conditionsAll) {
-						const aux: IDataObject = {};
-						aux.field = conditionAll.field;
-						aux.operator = conditionAll.operation;
-						if (conditionAll.operation !== 'changed' && conditionAll.operation !== 'not_changed') {
-							aux.value = conditionAll.value;
-						} else {
-							aux.value = null;
-						}
-						resultAll.push(aux);
-					}
-				}
-
-				const conditionsAny = conditions.any as [IDataObject];
-				if (conditionsAny) {
-					for (const conditionAny of conditionsAny) {
-						const aux: IDataObject = {};
-						aux.field = conditionAny.field;
-						aux.operator = conditionAny.operation;
-						if (conditionAny.operation !== 'changed' && conditionAny.operation !== 'not_changed') {
-							aux.value = conditionAny.value;
-						} else {
-							aux.value = null;
-						}
-						resultAny.push(aux);
-					}
-				}
-
-				// get all webhooks
+				// ── Step 1: find the Zendesk webhook by endpoint URL ────────────────
 				// https://developer.zendesk.com/api-reference/event-connectors/webhooks/webhooks/#list-webhooks
-				const { webhooks } = await zendeskApiRequest.call(this, 'GET', '/webhooks');
-				for (const webhook of webhooks) {
-					if (webhook.endpoint === webhookUrl) {
-						webhookData.targetId = webhook.id;
-						break;
-					}
-				}
+				const webhooksResponse = await zendeskApiRequest.call(this, 'GET', '/webhooks');
+				const webhooks: Array<{ id: string; endpoint: string }> = webhooksResponse.webhooks ?? [];
 
-				// no target was found
-				if (webhookData.targetId === undefined) {
+				const matchingWebhook = webhooks.find((w) => w.endpoint === webhookUrl);
+
+				if (!matchingWebhook) {
+					// Webhook is gone — clear any stale references so create() starts fresh
+					delete webhookData.targetId;
+					delete webhookData.webhookId;
 					return false;
 				}
 
-				endpoint = '/triggers/active';
-				const triggers = await zendeskApiRequestAllItems.call(this, 'triggers', 'GET', endpoint);
+				// Keep targetId in sync with Zendesk (the ID is stable, but be defensive)
+				webhookData.targetId = matchingWebhook.id;
 
-				for (const trigger of triggers) {
-					const toDeleteTriggers = [];
-					// this trigger belong to the current target
-					if (trigger.actions[0].value[0].toString() === webhookData.targetId?.toString()) {
-						toDeleteTriggers.push(trigger.id);
-					}
-					// delete all trigger attach to this target;
-					if (toDeleteTriggers.length !== 0) {
-						await zendeskApiRequest.call(
-							this,
-							'DELETE',
-							'/triggers/destroy_many',
-							{},
-							{ ids: toDeleteTriggers.join(',') },
-						);
-					}
+				// ── Step 2: confirm our specific trigger still exists ────────────────
+				// If we have no stored trigger ID this is a fresh activation (e.g. first
+				// run, or the workflow was duplicated). Fall through to create().
+				if (webhookData.webhookId === undefined) {
+					return false;
 				}
 
+				// https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#list-triggers
+				const triggers: Array<{
+					id: string | number;
+					actions: Array<{ field: string; value: string[] }>;
+				}> = await zendeskApiRequestAllItems.call(this, 'triggers', 'GET', '/triggers/active');
+
+				const ourTriggerExists = triggers.some(
+					(trigger) =>
+						trigger.id.toString() === (webhookData.webhookId as string).toString() &&
+						trigger.actions[0]?.field === 'notification_webhook' &&
+						trigger.actions[0]?.value[0]?.toString() === matchingWebhook.id,
+				);
+
+				if (ourTriggerExists) {
+					return true;
+				}
+
+				// Trigger is gone — clear the stale ID so create() makes a fresh one
+				delete webhookData.webhookId;
 				return false;
 			},
 			async create(this: IHookFunctions): Promise<boolean> {
@@ -400,13 +382,14 @@ export class ZendeskTrigger implements INodeType {
 
 					// Fetch the signing secret for webhook signature verification
 					// https://developer.zendesk.com/api-reference/event-connectors/webhooks/webhooks/#show-webhook-signing-secret
-					const signingSecretResponse = (await zendeskApiRequest.call(
+					const signingSecretResponse = await zendeskApiRequest.call(
 						this,
 						'GET',
-						`/webhooks/${target.id as string}/signing_secret`,
-					)) as { signing_secret?: { secret?: string } };
-					if (signingSecretResponse.signing_secret?.secret) {
-						webhookData.webhookSecret = signingSecretResponse.signing_secret.secret;
+						`/webhooks/${String(target.id)}/signing_secret`,
+					);
+					const secret: string | undefined = signingSecretResponse?.signing_secret?.secret;
+					if (secret) {
+						webhookData.webhookSecret = secret;
 					}
 
 					((bodyTrigger.trigger as IDataObject).actions as IDataObject[])[0].value = [
@@ -422,16 +405,40 @@ export class ZendeskTrigger implements INodeType {
 			},
 			async delete(this: IHookFunctions): Promise<boolean> {
 				const webhookData = this.getWorkflowStaticData('node');
+				let deletionSucceeded = true;
 				try {
 					await zendeskApiRequest.call(this, 'DELETE', `/triggers/${webhookData.webhookId}`);
-					await zendeskApiRequest.call(this, 'DELETE', `/webhooks/${webhookData.targetId}`);
-				} catch (error) {
-					return false;
+
+					// Only delete the Zendesk webhook if no other triggers still reference it.
+					// A duplicated n8n workflow shares the same webhook URL and may have its
+					// own trigger pointing at the same Zendesk webhook — deleting the webhook
+					// would silently break the sibling workflow's incoming events.
+					const remainingTriggers: Array<{
+						actions: Array<{ field: string; value: unknown[] }>;
+					}> = await zendeskApiRequestAllItems.call(this, 'triggers', 'GET', '/triggers/active');
+
+					const webhookStillInUse = remainingTriggers.some(
+						(trigger) =>
+							trigger.actions[0]?.field === 'notification_webhook' &&
+							String(trigger.actions[0]?.value[0]) === String(webhookData.targetId),
+					);
+
+					if (!webhookStillInUse) {
+						await zendeskApiRequest.call(this, 'DELETE', `/webhooks/${webhookData.targetId}`);
+					}
+				} catch {
+					// The remote resource may already be gone (e.g. deleted in Zendesk
+					// manually, or removed when a duplicated workflow was deactivated).
+					// We still fall through to the finally block so stale IDs are cleared,
+					// ensuring the next activation starts with a clean slate instead of
+					// trying to reuse a webhook that no longer exists.
+					deletionSucceeded = false;
+				} finally {
+					delete webhookData.webhookId;
+					delete webhookData.targetId;
+					delete webhookData.webhookSecret;
 				}
-				delete webhookData.webhookId;
-				delete webhookData.targetId;
-				delete webhookData.webhookSecret;
-				return true;
+				return deletionSucceeded;
 			},
 		},
 	};
diff --git a/packages/nodes-base/nodes/Zendesk/__tests__/ZendeskTrigger.node.test.ts b/packages/nodes-base/nodes/Zendesk/__tests__/ZendeskTrigger.node.test.ts
index 742aae76bcd..72e58ed4f9d 100644
--- a/packages/nodes-base/nodes/Zendesk/__tests__/ZendeskTrigger.node.test.ts
+++ b/packages/nodes-base/nodes/Zendesk/__tests__/ZendeskTrigger.node.test.ts
@@ -1,13 +1,38 @@
+import type { IHookFunctions } from 'n8n-workflow';
 import { ZendeskTrigger } from '../ZendeskTrigger.node';
 import * as GenericFunctions from '../GenericFunctions';
 import * as ZendeskTriggerHelpers from '../ZendeskTriggerHelpers';
 
+const WEBHOOK_URL = 'https://n8n.example.com/webhook/abc123';
+const ZENDESK_WEBHOOK_ID = 'zd-webhook-111';
+const ZENDESK_TRIGGER_ID = 'zd-trigger-222';
+
+function makeCheckExistsContext(webhookData: Record<string, unknown> = {}): IHookFunctions {
+	return {
+		getNodeWebhookUrl: () => WEBHOOK_URL,
+		getWorkflowStaticData: () => webhookData,
+	} as unknown as IHookFunctions;
+}
+
+const matchingWebhook = { id: ZENDESK_WEBHOOK_ID, endpoint: WEBHOOK_URL };
+
+const ownTrigger = {
+	id: ZENDESK_TRIGGER_ID,
+	actions: [{ field: 'notification_webhook', value: [ZENDESK_WEBHOOK_ID, '{}'] }],
+};
+
+const siblingTrigger = {
+	id: 'zd-trigger-sibling',
+	actions: [{ field: 'notification_webhook', value: [ZENDESK_WEBHOOK_ID, '{}'] }],
+};
+
 describe('ZendeskTrigger Node', () => {
 	describe('create webhook method', () => {
 		let mockThis: any;
 		let webhookData: Record<string, any>;
 
 		beforeEach(() => {
+			jest.clearAllMocks();
 			webhookData = {};
 			mockThis = {
 				getNodeWebhookUrl: () => 'https://example.com/webhook',
@@ -58,6 +83,31 @@ describe('ZendeskTrigger Node', () => {
 
 			expect(apiRequestSpy).toHaveBeenCalledWith('GET', '/webhooks/webhook-789/signing_secret');
 		});
+
+		it('should reuse the existing Zendesk webhook and skip POST /webhooks when targetId is already stored', async () => {
+			webhookData.targetId = 'existing-webhook-456';
+			const signingSecretResponse = { signing_secret: { secret: 'reused-secret' } };
+			const createdTrigger = { id: 'trigger-789' };
+
+			const apiRequestSpy = jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce(signingSecretResponse) // GET /webhooks/{id}/signing_secret
+				.mockResolvedValueOnce({ trigger: createdTrigger }); // POST /triggers
+
+			const trigger = new ZendeskTrigger();
+			const result = await trigger.webhookMethods.default.create.call(mockThis);
+
+			expect(result).toBe(true);
+			expect(webhookData.targetId).toBe('existing-webhook-456');
+			expect(webhookData.webhookSecret).toBe('reused-secret');
+			expect(webhookData.webhookId).toBe('trigger-789');
+
+			// POST /webhooks must not be called when a webhook already exists
+			const postWebhookCalls = apiRequestSpy.mock.calls.filter(
+				([method, path]) => method === 'POST' && path === '/webhooks',
+			);
+			expect(postWebhookCalls).toHaveLength(0);
+		});
 	});
 
 	describe('delete webhook method', () => {
@@ -65,6 +115,7 @@ describe('ZendeskTrigger Node', () => {
 		let mockThis: any;
 
 		beforeEach(() => {
+			jest.clearAllMocks();
 			webhookData = {
 				webhookId: 'trigger-123',
 				targetId: 'webhook-456',
@@ -81,6 +132,7 @@ describe('ZendeskTrigger Node', () => {
 				.spyOn(GenericFunctions, 'zendeskApiRequest')
 				.mockResolvedValueOnce({}) // DELETE /triggers
 				.mockResolvedValueOnce({}); // DELETE /webhooks
+			jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems').mockResolvedValueOnce([]); // no remaining triggers → webhook can be deleted
 
 			const trigger = new ZendeskTrigger();
 			const result = await trigger.webhookMethods.default.delete.call(mockThis);
@@ -101,6 +153,178 @@ describe('ZendeskTrigger Node', () => {
 
 			expect(result).toBe(false);
 		});
+
+		it('should clear static data even when the API call fails, so the next activation does not try to reuse a deleted webhook', async () => {
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockRejectedValueOnce(new Error('404 Not Found'));
+
+			const trigger = new ZendeskTrigger();
+			await trigger.webhookMethods.default.delete.call(mockThis);
+
+			// Stale IDs must be gone so the next activation does not try to reuse
+			// a Zendesk webhook that no longer exists (e.g. deleted via duplication).
+			expect(webhookData.webhookId).toBeUndefined();
+			expect(webhookData.targetId).toBeUndefined();
+			expect(webhookData.webhookSecret).toBeUndefined();
+		});
+
+		it('should not delete the Zendesk webhook when a sibling trigger still references it, so the duplicate workflow keeps receiving events', async () => {
+			const apiRequestSpy = jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({}); // DELETE /triggers
+			jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems').mockResolvedValueOnce([
+				// A sibling trigger still points at the same webhook
+				{
+					actions: [{ field: 'notification_webhook', value: [webhookData.targetId, '{}'] }],
+				},
+			]);
+
+			const trigger = new ZendeskTrigger();
+			const result = await trigger.webhookMethods.default.delete.call(mockThis);
+
+			expect(result).toBe(true);
+
+			// DELETE /webhooks must not have been called
+			const deleteWebhookCalls = apiRequestSpy.mock.calls.filter(
+				([method, path]) =>
+					method === 'DELETE' && typeof path === 'string' && path.startsWith('/webhooks'),
+			);
+			expect(deleteWebhookCalls).toHaveLength(0);
+		});
+	});
+
+	describe('checkExists webhook method', () => {
+		beforeEach(() => {
+			jest.clearAllMocks();
+		});
+
+		it('should return false and clear stale IDs when the webhook is not found in Zendesk, so create() starts fresh instead of reusing a deleted webhook', async () => {
+			jest.spyOn(GenericFunctions, 'zendeskApiRequest').mockResolvedValueOnce({
+				webhooks: [{ id: 'other-id', endpoint: 'https://other.example.com' }],
+			});
+
+			const webhookData: Record<string, unknown> = {
+				targetId: 'stale-webhook-id',
+				webhookId: 'stale-trigger-id',
+			};
+			const trigger = new ZendeskTrigger();
+
+			const result = await trigger.webhookMethods.default.checkExists.call(
+				makeCheckExistsContext(webhookData),
+			);
+
+			expect(result).toBe(false);
+			expect(webhookData.targetId).toBeUndefined();
+			expect(webhookData.webhookId).toBeUndefined();
+		});
+
+		it('should return false without fetching triggers on first activation, so create() registers a trigger for the existing webhook without an unnecessary API call', async () => {
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({ webhooks: [matchingWebhook] });
+			const allItemsSpy = jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems');
+
+			const webhookData: Record<string, unknown> = {};
+			const trigger = new ZendeskTrigger();
+
+			const result = await trigger.webhookMethods.default.checkExists.call(
+				makeCheckExistsContext(webhookData),
+			);
+
+			expect(result).toBe(false);
+			expect(webhookData.targetId).toBe(ZENDESK_WEBHOOK_ID);
+			// Triggers API must not be called — we know we need to create without checking
+			expect(allItemsSpy).not.toHaveBeenCalled();
+		});
+
+		it('should return true when both the webhook and our trigger are confirmed in Zendesk, so create() is skipped and the existing setup is preserved', async () => {
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({ webhooks: [matchingWebhook] });
+			jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems').mockResolvedValueOnce([ownTrigger]);
+
+			const webhookData: Record<string, unknown> = {
+				targetId: ZENDESK_WEBHOOK_ID,
+				webhookId: ZENDESK_TRIGGER_ID,
+			};
+			const trigger = new ZendeskTrigger();
+
+			const result = await trigger.webhookMethods.default.checkExists.call(
+				makeCheckExistsContext(webhookData),
+			);
+
+			expect(result).toBe(true);
+			expect(webhookData.targetId).toBe(ZENDESK_WEBHOOK_ID);
+			expect(webhookData.webhookId).toBe(ZENDESK_TRIGGER_ID);
+		});
+
+		it('should return false and clear the stale trigger ID when the webhook exists but our trigger is gone, so create() makes a new trigger without being blocked by the invalid ID', async () => {
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({ webhooks: [matchingWebhook] });
+			jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems').mockResolvedValueOnce([]);
+
+			const webhookData: Record<string, unknown> = {
+				targetId: ZENDESK_WEBHOOK_ID,
+				webhookId: ZENDESK_TRIGGER_ID,
+			};
+			const trigger = new ZendeskTrigger();
+
+			const result = await trigger.webhookMethods.default.checkExists.call(
+				makeCheckExistsContext(webhookData),
+			);
+
+			expect(result).toBe(false);
+			expect(webhookData.targetId).toBe(ZENDESK_WEBHOOK_ID); // webhook still present
+			expect(webhookData.webhookId).toBeUndefined(); // stale trigger ID cleared
+		});
+
+		it("should not issue any DELETE calls for triggers it does not own, so a duplicated workflow cannot silently destroy the original workflow's Zendesk trigger", async () => {
+			const apiRequestSpy = jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({ webhooks: [matchingWebhook] });
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequestAllItems')
+				.mockResolvedValueOnce([siblingTrigger]);
+
+			// Our stored webhookId is different from the sibling's trigger ID
+			const webhookData: Record<string, unknown> = {
+				targetId: ZENDESK_WEBHOOK_ID,
+				webhookId: ZENDESK_TRIGGER_ID,
+			};
+			const trigger = new ZendeskTrigger();
+
+			await trigger.webhookMethods.default.checkExists.call(makeCheckExistsContext(webhookData));
+
+			const deleteCalls = apiRequestSpy.mock.calls.filter(([method]) => method === 'DELETE');
+			expect(deleteCalls).toHaveLength(0);
+		});
+
+		it('should not match a trigger whose action field is not notification_webhook, so unrelated Zendesk triggers with coincidental IDs are never treated as ours', async () => {
+			jest
+				.spyOn(GenericFunctions, 'zendeskApiRequest')
+				.mockResolvedValueOnce({ webhooks: [matchingWebhook] });
+			jest.spyOn(GenericFunctions, 'zendeskApiRequestAllItems').mockResolvedValueOnce([
+				// Same ID as our stored webhookId but wrong action type
+				{
+					id: ZENDESK_TRIGGER_ID,
+					actions: [{ field: 'notification_user', value: ['user@example.com'] }],
+				},
+			]);
+
+			const webhookData: Record<string, unknown> = {
+				targetId: ZENDESK_WEBHOOK_ID,
+				webhookId: ZENDESK_TRIGGER_ID,
+			};
+			const trigger = new ZendeskTrigger();
+
+			const result = await trigger.webhookMethods.default.checkExists.call(
+				makeCheckExistsContext(webhookData),
+			);
+
+			expect(result).toBe(false);
+		});
 	});
 
 	describe('webhook method', () => {
diff --git a/packages/testing/code-health/src/index.ts b/packages/testing/code-health/src/index.ts
index fc89d367b1e..56401bc9fc8 100644
--- a/packages/testing/code-health/src/index.ts
+++ b/packages/testing/code-health/src/index.ts
@@ -3,9 +3,13 @@ import type { RuleSettingsMap } from '@n8n/rules-engine';
 
 import type { CodeHealthContext } from './context.js';
 import { CatalogViolationsRule } from './rules/catalog-violations.rule.js';
+import { MigrationTimestampRule } from './rules/migration-timestamp.rule.js';
+import { WorkflowPrTargetSafetyRule } from './rules/workflow-pr-target-safety.rule.js';
 
 export type { CodeHealthContext } from './context.js';
 export { CatalogViolationsRule } from './rules/catalog-violations.rule.js';
+export { MigrationTimestampRule } from './rules/migration-timestamp.rule.js';
+export { WorkflowPrTargetSafetyRule } from './rules/workflow-pr-target-safety.rule.js';
 
 const defaultRuleSettings: RuleSettingsMap = {
 	'catalog-violations': {
@@ -13,6 +17,16 @@ const defaultRuleSettings: RuleSettingsMap = {
 		severity: 'error',
 		options: { workspaceFile: 'pnpm-workspace.yaml' },
 	},
+	'workflow-pr-target-safety': {
+		enabled: true,
+		severity: 'error',
+		options: { allowedWorkflows: ['ci-cla-check.yml'] },
+	},
+	'migration-timestamp': {
+		enabled: true,
+		severity: 'error',
+		options: {},
+	},
 };
 
 function mergeSettings(defaults: RuleSettingsMap, overrides?: RuleSettingsMap): RuleSettingsMap {
@@ -31,6 +45,8 @@ function mergeSettings(defaults: RuleSettingsMap, overrides?: RuleSettingsMap):
 export function createDefaultRunner(settings?: RuleSettingsMap): RuleRunner<CodeHealthContext> {
 	const runner = new RuleRunner<CodeHealthContext>();
 	runner.registerRule(new CatalogViolationsRule());
+	runner.registerRule(new WorkflowPrTargetSafetyRule());
+	runner.registerRule(new MigrationTimestampRule());
 	runner.applySettings(mergeSettings(defaultRuleSettings, settings));
 	return runner;
 }
diff --git a/packages/testing/code-health/src/rules/migration-timestamp.rule.test.ts b/packages/testing/code-health/src/rules/migration-timestamp.rule.test.ts
new file mode 100644
index 00000000000..e18ae74eaa2
--- /dev/null
+++ b/packages/testing/code-health/src/rules/migration-timestamp.rule.test.ts
@@ -0,0 +1,96 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import type { CodeHealthContext } from '../context.js';
+import { MigrationTimestampRule } from './migration-timestamp.rule.js';
+
+const NOW = 1_777_000_000_000; // fixed reference time used in assertions
+
+const MIGRATIONS_DIR = path.join('packages', '@n8n', 'db', 'src', 'migrations', 'postgresdb');
+
+function createTempDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), 'code-health-migration-test-'));
+}
+
+function writeMigration(rootDir: string, fileName: string, content = 'export {};\n'): void {
+	const fullPath = path.join(rootDir, MIGRATIONS_DIR, fileName);
+	fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+	fs.writeFileSync(fullPath, content);
+}
+
+describe('MigrationTimestampRule', () => {
+	let tmpDir: string;
+	let rule: MigrationTimestampRule;
+
+	beforeEach(() => {
+		tmpDir = createTempDir();
+		rule = new MigrationTimestampRule();
+		rule.configure({ options: { now: NOW } });
+	});
+
+	afterEach(() => {
+		fs.rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	function context(): CodeHealthContext {
+		return { rootDir: tmpDir };
+	}
+
+	it('accepts a precise past timestamp', async () => {
+		writeMigration(tmpDir, '1761047826451-AddWorkflowVersionColumn.ts');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('accepts a rounded past timestamp', async () => {
+		writeMigration(tmpDir, '1766500000000-ExpandInsightsWorkflowIdLength.ts');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('flags a future timestamp', async () => {
+		writeMigration(tmpDir, '1784000000000-AiHallucinatedMigration.ts');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].rule).toBe('migration-timestamp');
+		expect(violations[0].message).toContain('future timestamp');
+		expect(violations[0].message).toContain('1784000000000');
+	});
+
+	it('ignores index.ts and other non-migration files', async () => {
+		writeMigration(tmpDir, 'index.ts');
+		writeMigration(tmpDir, 'README.md');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('scans every configured migration directory', async () => {
+		writeMigration(tmpDir, '1784000000000-Postgres.ts');
+		const sqlitePath = path.join(
+			tmpDir,
+			'packages',
+			'@n8n',
+			'db',
+			'src',
+			'migrations',
+			'sqlite',
+			'1784000000001-Sqlite.ts',
+		);
+		fs.mkdirSync(path.dirname(sqlitePath), { recursive: true });
+		fs.writeFileSync(sqlitePath, 'export {};\n');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(2);
+	});
+});
diff --git a/packages/testing/code-health/src/rules/migration-timestamp.rule.ts b/packages/testing/code-health/src/rules/migration-timestamp.rule.ts
new file mode 100644
index 00000000000..c902b09de50
--- /dev/null
+++ b/packages/testing/code-health/src/rules/migration-timestamp.rule.ts
@@ -0,0 +1,67 @@
+import { BaseRule } from '@n8n/rules-engine';
+import type { Violation } from '@n8n/rules-engine';
+import fg from 'fast-glob';
+import * as path from 'node:path';
+
+import type { CodeHealthContext } from '../context.js';
+
+const DEFAULT_MIGRATION_GLOBS = [
+	'packages/@n8n/db/src/migrations/common/*.ts',
+	'packages/@n8n/db/src/migrations/postgresdb/*.ts',
+	'packages/@n8n/db/src/migrations/sqlite/*.ts',
+];
+
+const MIGRATION_FILENAME = /^(\d{10,16})-.+\.ts$/;
+
+export class MigrationTimestampRule extends BaseRule<CodeHealthContext> {
+	readonly id = 'migration-timestamp';
+	readonly name = 'Migration Timestamp Hygiene';
+	readonly description =
+		'Migration filenames must be prefixed with a Date.now() value from the past — not a future timestamp.';
+	readonly severity = 'error' as const;
+
+	async analyze(context: CodeHealthContext): Promise<Violation[]> {
+		const { rootDir } = context;
+		const options = this.getOptions();
+
+		const globs = Array.isArray(options.migrationGlobs)
+			? (options.migrationGlobs as string[])
+			: DEFAULT_MIGRATION_GLOBS;
+		const now = typeof options.now === 'number' ? options.now : Date.now();
+
+		const files = await fg(globs, { cwd: rootDir, absolute: true });
+
+		const violations: Violation[] = [];
+		for (const filePath of files) {
+			const fileName = path.basename(filePath);
+			const match = MIGRATION_FILENAME.exec(fileName);
+			if (!match) continue;
+
+			const timestamp = Number(match[1]);
+			if (!Number.isFinite(timestamp)) continue;
+			if (timestamp <= now) continue;
+
+			violations.push(
+				this.createViolation(
+					filePath,
+					1,
+					1,
+					`${fileName} is prefixed with a future timestamp (${timestamp}, ${formatDelta(timestamp - now)} ahead of now). Migration prefixes must be the exact Date.now() value at the time of creation — AI agents commonly fabricate future timestamps.`,
+					"Rename the file using the current millisecond timestamp from Date.now() (or 'date +%s%3N').",
+				),
+			);
+		}
+
+		return violations;
+	}
+}
+
+function formatDelta(ms: number): string {
+	const abs = Math.abs(ms);
+	const days = Math.floor(abs / 86_400_000);
+	if (days >= 1) return `~${days}d`;
+	const hours = Math.floor(abs / 3_600_000);
+	if (hours >= 1) return `~${hours}h`;
+	const minutes = Math.floor(abs / 60_000);
+	return `~${minutes}m`;
+}
diff --git a/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.test.ts b/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.test.ts
new file mode 100644
index 00000000000..18b080a7676
--- /dev/null
+++ b/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.test.ts
@@ -0,0 +1,267 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import type { CodeHealthContext } from '../context.js';
+import { WorkflowPrTargetSafetyRule } from './workflow-pr-target-safety.rule.js';
+
+function createTempDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), 'code-health-workflow-test-'));
+}
+
+function writeWorkflow(dir: string, name: string, content: string): void {
+	const fullPath = path.join(dir, '.github', 'workflows', name);
+	fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+	fs.writeFileSync(fullPath, content);
+}
+
+describe('WorkflowPrTargetSafetyRule', () => {
+	let tmpDir: string;
+	let rule: WorkflowPrTargetSafetyRule;
+
+	beforeEach(() => {
+		tmpDir = createTempDir();
+		rule = new WorkflowPrTargetSafetyRule();
+		rule.configure({ options: { allowedWorkflows: ['ci-cla-check.yml'] } });
+	});
+
+	afterEach(() => {
+		fs.rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	function context(): CodeHealthContext {
+		return { rootDir: tmpDir };
+	}
+
+	it('ignores workflows that only use pull_request', async () => {
+		writeWorkflow(
+			tmpDir,
+			'safe.yml',
+			`
+name: Safe
+on:
+  pull_request:
+    types: [opened]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: \${{ github.event.pull_request.head.sha }}
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('flags any non-allowlisted workflow that uses pull_request_target', async () => {
+		writeWorkflow(
+			tmpDir,
+			'risky.yml',
+			`
+name: Risky
+on:
+  pull_request_target:
+    types: [opened]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].rule).toBe('workflow-pr-target-safety');
+		expect(violations[0].message).toContain('pull_request_target');
+		expect(violations[0].message).toContain('Prefer pull_request');
+	});
+
+	it('flags pull_request_target even when on: is a list', async () => {
+		writeWorkflow(
+			tmpDir,
+			'list-trigger.yml',
+			`
+name: List
+on: [pull_request_target]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+	});
+
+	it('allows pull_request_target in an allowlisted workflow with no checkout override', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+    types: [opened]
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts/cla
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('flags allowlisted workflow that checks out PR head sha', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+    types: [opened]
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: \${{ github.event.pull_request.head.sha }}
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].message).toContain('PR-author-controlled ref');
+		expect(violations[0].message).toContain('their code, our keys');
+	});
+
+	it('flags allowlisted workflow that checks out github.head_ref', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: \${{ github.head_ref }}
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].message).toContain('PR-author-controlled ref');
+	});
+
+	it('flags allowlisted workflow that checks out PR fork repository', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          repository: \${{ github.event.pull_request.head.repo.full_name }}
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].message).toContain('PR-author-controlled repository');
+	});
+
+	it('flags shell git checkout of PR head ref', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Fetch PR
+        run: |
+          git fetch origin \${{ github.event.pull_request.head.sha }}
+          git checkout FETCH_HEAD
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(1);
+		expect(violations[0].message).toContain('shell git command');
+	});
+
+	it('does not flag a checkout with no ref override', async () => {
+		writeWorkflow(
+			tmpDir,
+			'ci-cla-check.yml',
+			`
+name: CLA Check
+on:
+  pull_request_target:
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          path: vendor
+`,
+		);
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('handles workflows with no triggers without throwing', async () => {
+		writeWorkflow(tmpDir, 'broken.yml', 'name: Broken\njobs: {}\n');
+
+		const violations = await rule.analyze(context());
+
+		expect(violations).toHaveLength(0);
+	});
+
+	it('skips files that are not valid YAML', async () => {
+		writeWorkflow(tmpDir, 'invalid.yml', '::: not yaml :::\n\t- broken');
+
+		await expect(rule.analyze(context())).resolves.toBeDefined();
+	});
+});
diff --git a/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.ts b/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.ts
new file mode 100644
index 00000000000..1ebaaf7be94
--- /dev/null
+++ b/packages/testing/code-health/src/rules/workflow-pr-target-safety.rule.ts
@@ -0,0 +1,150 @@
+import { BaseRule } from '@n8n/rules-engine';
+import type { Violation } from '@n8n/rules-engine';
+import * as path from 'node:path';
+
+import type { CodeHealthContext } from '../context.js';
+import {
+	findLineContaining,
+	findWorkflowFiles,
+	parseWorkflow,
+	type WorkflowFile,
+	type WorkflowJobStep,
+} from '../utils/workflow-scanner.js';
+
+const RISKY_TRIGGER = 'pull_request_target';
+
+const UNTRUSTED_REF_EXPRESSIONS = [
+	'github.event.pull_request.head.sha',
+	'github.event.pull_request.head.ref',
+	'github.event.pull_request.merge_commit_sha',
+	'github.head_ref',
+];
+
+const UNTRUSTED_REPOSITORY_EXPRESSIONS = [
+	'github.event.pull_request.head.repo.full_name',
+	'github.event.pull_request.head.repo.clone_url',
+];
+
+export class WorkflowPrTargetSafetyRule extends BaseRule<CodeHealthContext> {
+	readonly id = 'workflow-pr-target-safety';
+	readonly name = 'Workflow pull_request_target Safety';
+	readonly description =
+		'Disallow pull_request_target triggers. Allowlisted workflows may use it only if they do not check out PR-author-controlled code.';
+	readonly severity = 'error' as const;
+
+	async analyze(context: CodeHealthContext): Promise<Violation[]> {
+		const { rootDir } = context;
+		const options = this.getOptions();
+		const allowedWorkflows = Array.isArray(options.allowedWorkflows)
+			? (options.allowedWorkflows as string[])
+			: [];
+
+		const files = await findWorkflowFiles(rootDir);
+		const violations: Violation[] = [];
+
+		for (const filePath of files) {
+			const workflow = parseWorkflow(filePath, rootDir);
+			if (!workflow) continue;
+			if (!workflow.triggers.includes(RISKY_TRIGGER)) continue;
+
+			const fileName = path.basename(filePath);
+			if (!allowedWorkflows.includes(fileName)) {
+				violations.push(this.flagTrigger(workflow));
+				continue;
+			}
+
+			violations.push(...this.flagUnsafeCheckouts(workflow));
+		}
+
+		return violations;
+	}
+
+	private flagTrigger(workflow: WorkflowFile): Violation {
+		return this.createViolation(
+			workflow.filePath,
+			findLineContaining(workflow.lines, RISKY_TRIGGER),
+			1,
+			`${workflow.relativePath} uses pull_request_target. Prefer pull_request — pull_request_target runs in the base-repo context with secrets exposed, which is unsafe when combined with PR-author-controlled code.`,
+			'Switch to pull_request, or if pull_request_target is required, request a security review and add this workflow to the rule allowlist.',
+		);
+	}
+
+	private flagUnsafeCheckouts(workflow: WorkflowFile): Violation[] {
+		const violations: Violation[] = [];
+
+		for (const job of workflow.jobs) {
+			for (const step of job.steps) {
+				violations.push(...this.flagCheckoutAction(workflow, job.id, step));
+				violations.push(...this.flagShellCheckout(workflow, job.id, step));
+			}
+		}
+
+		return violations;
+	}
+
+	private flagCheckoutAction(
+		workflow: WorkflowFile,
+		jobId: string,
+		step: WorkflowJobStep,
+	): Violation[] {
+		if (!step.uses?.startsWith('actions/checkout@')) return [];
+		const stepWith = step.with;
+		if (!stepWith) return [];
+
+		const violations: Violation[] = [];
+		const stepLine = findLineContaining(workflow.lines, step.uses);
+
+		const ref = typeof stepWith.ref === 'string' ? stepWith.ref : undefined;
+		if (ref && containsExpression(ref, UNTRUSTED_REF_EXPRESSIONS)) {
+			violations.push(
+				this.createViolation(
+					workflow.filePath,
+					findLineContaining(workflow.lines, 'ref:', stepLine),
+					1,
+					`${workflow.relativePath} job "${jobId}" checks out PR-author-controlled ref under pull_request_target. This pattern ("their code, our keys") is the canonical pull_request_target exploit.`,
+					'Remove the ref override (defaults to the base branch), or move this step to a workflow triggered by pull_request.',
+				),
+			);
+		}
+
+		const repository = typeof stepWith.repository === 'string' ? stepWith.repository : undefined;
+		if (repository && containsExpression(repository, UNTRUSTED_REPOSITORY_EXPRESSIONS)) {
+			violations.push(
+				this.createViolation(
+					workflow.filePath,
+					findLineContaining(workflow.lines, 'repository:', stepLine),
+					1,
+					`${workflow.relativePath} job "${jobId}" checks out a PR-author-controlled repository under pull_request_target.`,
+					'Remove the repository override so the checkout stays on github.repository.',
+				),
+			);
+		}
+
+		return violations;
+	}
+
+	private flagShellCheckout(
+		workflow: WorkflowFile,
+		jobId: string,
+		step: WorkflowJobStep,
+	): Violation[] {
+		if (!step.run) return [];
+		const usesGitCheckout = /\bgit\s+(checkout|fetch|pull)\b/.test(step.run);
+		if (!usesGitCheckout) return [];
+		if (!containsExpression(step.run, UNTRUSTED_REF_EXPRESSIONS)) return [];
+
+		return [
+			this.createViolation(
+				workflow.filePath,
+				findLineContaining(workflow.lines, 'run:'),
+				1,
+				`${workflow.relativePath} job "${jobId}" runs a shell git command that fetches PR-author-controlled refs under pull_request_target.`,
+				'Avoid checking out PR head from a pull_request_target workflow; do the work in a pull_request-triggered workflow instead.',
+			),
+		];
+	}
+}
+
+function containsExpression(value: string, needles: string[]): boolean {
+	return needles.some((needle) => value.includes(needle));
+}
diff --git a/packages/testing/code-health/src/utils/workflow-scanner.ts b/packages/testing/code-health/src/utils/workflow-scanner.ts
new file mode 100644
index 00000000000..3cb9e9ece37
--- /dev/null
+++ b/packages/testing/code-health/src/utils/workflow-scanner.ts
@@ -0,0 +1,105 @@
+import fg from 'fast-glob';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+
+export interface WorkflowJobStep {
+	name?: string;
+	uses?: string;
+	run?: string;
+	with?: Record<string, unknown>;
+}
+
+export interface WorkflowJob {
+	id: string;
+	steps: WorkflowJobStep[];
+}
+
+export interface WorkflowFile {
+	filePath: string;
+	relativePath: string;
+	lines: string[];
+	triggers: string[];
+	jobs: WorkflowJob[];
+}
+
+export async function findWorkflowFiles(rootDir: string): Promise<string[]> {
+	return await fg('.github/workflows/*.{yml,yaml}', {
+		cwd: rootDir,
+		absolute: true,
+		dot: true,
+	});
+}
+
+export function parseWorkflow(filePath: string, rootDir: string): WorkflowFile | null {
+	const content = fs.readFileSync(filePath, 'utf-8');
+	const lines = content.split('\n');
+
+	let doc: unknown;
+	try {
+		doc = parseYaml(content);
+	} catch {
+		return null;
+	}
+
+	if (!doc || typeof doc !== 'object') return null;
+
+	const workflow = doc as Record<string, unknown>;
+	// YAML's `on:` keyword gets parsed as boolean `true` by the yaml lib
+	// unless quoted, so check both keys.
+	const onValue = workflow.on ?? workflow.true;
+
+	return {
+		filePath,
+		relativePath: path.relative(rootDir, filePath),
+		lines,
+		triggers: extractTriggers(onValue),
+		jobs: extractJobs(workflow.jobs),
+	};
+}
+
+function extractTriggers(onValue: unknown): string[] {
+	if (typeof onValue === 'string') return [onValue];
+	if (Array.isArray(onValue)) return onValue.filter((t): t is string => typeof t === 'string');
+	if (onValue && typeof onValue === 'object') return Object.keys(onValue);
+	return [];
+}
+
+function extractJobs(jobsValue: unknown): WorkflowJob[] {
+	if (!jobsValue || typeof jobsValue !== 'object') return [];
+
+	const jobs: WorkflowJob[] = [];
+	for (const [id, raw] of Object.entries(jobsValue as Record<string, unknown>)) {
+		if (!raw || typeof raw !== 'object') continue;
+		const job = raw as Record<string, unknown>;
+		const stepsValue = job.steps;
+		if (!Array.isArray(stepsValue)) {
+			jobs.push({ id, steps: [] });
+			continue;
+		}
+
+		const steps: WorkflowJobStep[] = [];
+		for (const stepRaw of stepsValue) {
+			if (!stepRaw || typeof stepRaw !== 'object') continue;
+			const step = stepRaw as Record<string, unknown>;
+			steps.push({
+				name: typeof step.name === 'string' ? step.name : undefined,
+				uses: typeof step.uses === 'string' ? step.uses : undefined,
+				run: typeof step.run === 'string' ? step.run : undefined,
+				with:
+					step.with && typeof step.with === 'object'
+						? (step.with as Record<string, unknown>)
+						: undefined,
+			});
+		}
+		jobs.push({ id, steps });
+	}
+	return jobs;
+}
+
+export function findLineContaining(lines: string[], needle: string, startLine = 0): number {
+	for (let i = startLine; i < lines.length; i++) {
+		if (lines[i].includes(needle)) return i + 1;
+	}
+	return 1;
+}
diff --git a/packages/testing/playwright/.janitor-baseline.json b/packages/testing/playwright/.janitor-baseline.json
index c6ab0438226..a4968bf0e37 100644
--- a/packages/testing/playwright/.janitor-baseline.json
+++ b/packages/testing/playwright/.janitor-baseline.json
@@ -1,7 +1,7 @@
 {
 	"version": 1,
-	"generated": "2026-05-12T08:06:17.170Z",
-	"totalViolations": 416,
+	"generated": "2026-05-12T11:24:54.376Z",
+	"totalViolations": 410,
 	"violations": {
 		"pages/AIAssistantPage.ts": [
 			{
@@ -82,13 +82,7 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 274,
-				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
-				"hash": "4087a9cf20cb"
-			},
-			{
-				"rule": "scope-lockdown",
-				"line": 323,
+				"line": 278,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -106,7 +100,7 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 351,
+				"line": 335,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -136,31 +130,25 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 373,
+				"line": 371,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 399,
+				"line": 377,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 435,
+				"line": 403,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 463,
-				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
-				"hash": "4087a9cf20cb"
-			},
-			{
-				"rule": "scope-lockdown",
-				"line": 467,
+				"line": 439,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -176,6 +164,12 @@
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
+			{
+				"rule": "scope-lockdown",
+				"line": 471,
+				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
+				"hash": "4087a9cf20cb"
+			},
 			{
 				"rule": "scope-lockdown",
 				"line": 475,
@@ -184,7 +178,7 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 493,
+				"line": 479,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -196,49 +190,43 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 497,
+				"line": 501,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 508,
+				"line": 501,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 517,
+				"line": 512,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 579,
+				"line": 521,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 624,
+				"line": 583,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 630,
+				"line": 628,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 654,
-				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
-				"hash": "4087a9cf20cb"
-			},
-			{
-				"rule": "scope-lockdown",
-				"line": 654,
+				"line": 634,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -250,19 +238,25 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 765,
+				"line": 658,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 810,
+				"line": 662,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 864,
+				"line": 769,
+				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
+				"hash": "4087a9cf20cb"
+			},
+			{
+				"rule": "scope-lockdown",
+				"line": 814,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
@@ -274,13 +268,19 @@
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 877,
+				"line": 872,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			},
 			{
 				"rule": "scope-lockdown",
-				"line": 883,
+				"line": 885,
+				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
+				"hash": "4087a9cf20cb"
+			},
+			{
+				"rule": "scope-lockdown",
+				"line": 891,
 				"message": "NodeDetailsViewPage: Unscoped locator - use this.container instead of this.page",
 				"hash": "4087a9cf20cb"
 			}
@@ -1547,20 +1547,6 @@
 				"hash": "e286b40da00e"
 			}
 		],
-		"tests/e2e/workflows/editor/expressions/transformation.spec.ts": [
-			{
-				"rule": "selector-purity",
-				"line": 114,
-				"message": "Chained locator call in test: n8n.ndv.getOutputDataContainer().locator('[class*=value_]')",
-				"hash": "5ce9a307e353"
-			},
-			{
-				"rule": "selector-purity",
-				"line": 134,
-				"message": "Chained locator call in test: n8n.ndv.getOutputDataContainer().locator('[class*=value_]')",
-				"hash": "5ce9a307e353"
-			}
-		],
 		"tests/e2e/workflows/editor/ndv/io-filter.spec.ts": [
 			{
 				"rule": "selector-purity",
@@ -1853,14 +1839,6 @@
 				"hash": "6ccf615ddb0b"
 			}
 		],
-		"tests/e2e/workflows/editor/subworkflows/workflow-selector.spec.ts": [
-			{
-				"rule": "selector-purity",
-				"line": 92,
-				"message": "Chained locator call in test: addResourceItem.getByText(/Create a/)",
-				"hash": "46294c103c93"
-			}
-		],
 		"tests/e2e/workflows/editor/tags.spec.ts": [
 			{
 				"rule": "selector-purity",
@@ -2471,26 +2449,6 @@
 				"hash": "0acea681877b"
 			}
 		],
-		"utils/benchmark/instance-ai-driver.ts": [
-			{
-				"rule": "dead-code",
-				"line": 263,
-				"message": "Unused method: InstanceAiDriver.deleteAllThreads()",
-				"hash": "84fa4accc8fa"
-			},
-			{
-				"rule": "dead-code",
-				"line": 302,
-				"message": "Unused method: InstanceAiDriver.measureHeap()",
-				"hash": "40ed597f87ba"
-			},
-			{
-				"rule": "dead-code",
-				"line": 307,
-				"message": "Unused method: InstanceAiDriver.snapshot()",
-				"hash": "70bd4d633512"
-			}
-		],
 		"pages/ChatHubSettingsPage.ts": [
 			{
 				"rule": "deduplication",
diff --git a/packages/testing/playwright/pages/InstanceAiPage.ts b/packages/testing/playwright/pages/InstanceAiPage.ts
index 31fc8afb513..1f86b8992c4 100644
--- a/packages/testing/playwright/pages/InstanceAiPage.ts
+++ b/packages/testing/playwright/pages/InstanceAiPage.ts
@@ -167,8 +167,12 @@ export class InstanceAiPage extends BasePage {
 		return this.getPreviewIframe().locator('[data-test-id="canvas-node-status-success"]');
 	}
 
-	getPreviewCloseButton(): Locator {
-		return this.container.getByTestId('instance-ai-preview-close');
+	getPreviewToggleButton(): Locator {
+		return this.getPreviewPanel().getByTestId('instance-ai-artifacts-preview-toggle');
+	}
+
+	getPreviewPanel(): Locator {
+		return this.container.getByTestId('instance-ai-preview-panel');
 	}
 
 	getPreviewIframeLocator(): Locator {
@@ -185,6 +189,12 @@ export class InstanceAiPage extends BasePage {
 		);
 	}
 
+	async openPreviewNodeByName(nodeName: string): Promise<void> {
+		const node = this.getPreviewNodeByName(nodeName);
+		await node.waitFor({ state: 'visible', timeout: 10_000 });
+		await node.dblclick();
+	}
+
 	getPreviewExecuteNodeButton(nodeName: string): Locator {
 		return this.getPreviewNodeByName(nodeName).getByRole('button', { name: 'Execute step' });
 	}
diff --git a/packages/testing/playwright/pages/NodeDetailsViewPage.ts b/packages/testing/playwright/pages/NodeDetailsViewPage.ts
index eda2a30185b..9669e5162c5 100644
--- a/packages/testing/playwright/pages/NodeDetailsViewPage.ts
+++ b/packages/testing/playwright/pages/NodeDetailsViewPage.ts
@@ -143,6 +143,10 @@ export class NodeDetailsViewPage extends BasePage {
 		return this.getOutputPanel().getByTestId('ndv-data-container');
 	}
 
+	getOutputDataValues() {
+		return this.getOutputDataContainer().locator('[class*=value_]');
+	}
+
 	async setPinnedData(data: object | string) {
 		const pinnedData = typeof data === 'string' ? data : JSON.stringify(data);
 		await this.getEditPinnedDataButton().click();
@@ -868,6 +872,10 @@ export class NodeDetailsViewPage extends BasePage {
 		return this.page.getByTestId('rlc-item-add-resource');
 	}
 
+	getAddResourceCreateOption() {
+		return this.getAddResourceItem().getByText(/Create a/);
+	}
+
 	getExpressionModeToggle(index: number = 1) {
 		return this.container.getByTestId('radio-button-expression').nth(index);
 	}
diff --git a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-artifacts.spec.ts b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-artifacts.spec.ts
index 3adcc930951..96e90778a1f 100644
--- a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-artifacts.spec.ts
+++ b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-artifacts.spec.ts
@@ -41,8 +41,8 @@ test.describe(
 				timeout: 30_000,
 			});
 
-			// Close the preview first
-			await n8n.instanceAi.getPreviewCloseButton().click();
+			// Hide the preview first
+			await n8n.instanceAi.getPreviewToggleButton().click();
 			await expect(n8n.instanceAi.getPreviewIframeLocator()).toBeHidden();
 
 			// Click the artifact card to re-open the preview
diff --git a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-timeouts.spec.ts b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-timeouts.spec.ts
index 2338e44f391..f573d6f45e9 100644
--- a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-timeouts.spec.ts
+++ b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-timeouts.spec.ts
@@ -3,34 +3,27 @@ import { test, expect, instanceAiTestConfig } from './fixtures';
 test.use(instanceAiTestConfig);
 
 test.describe('Instance AI timeouts', () => {
-	test.beforeEach(({}, testInfo) => {
-		test.skip(
-			testInfo.project.name.includes('multi-main'),
-			'Instance AI background-task state is per-main-process; the seed endpoint and the browser may land on different mains.',
-		);
-	});
+	test.fixme(
+		'should show a timeout message when a stuck background task times out',
+		async ({ api, n8n }) => {
+			const owner = await api.signin('owner');
+			const simulation = await api.startInstanceAiBackgroundTimeoutSimulation(owner.id);
 
-	test('should show a timeout message when a stuck background task times out', async ({
-		api,
-		n8n,
-	}) => {
-		const owner = await api.signin('owner');
-		const simulation = await api.startInstanceAiBackgroundTimeoutSimulation(owner.id);
+			await n8n.instanceAi.gotoThread(simulation.threadId);
+			await expect(n8n.instanceAi.getAssistantMessages().first()).toContainText(
+				'I started a background workflow-builder task.',
+				{ timeout: 15_000 },
+			);
+			await expect(n8n.instanceAi.getBackgroundTaskIndicator()).toBeVisible({ timeout: 15_000 });
 
-		await n8n.instanceAi.gotoThread(simulation.threadId);
-		await expect(n8n.instanceAi.getAssistantMessages().first()).toContainText(
-			'I started a background workflow-builder task.',
-			{ timeout: 15_000 },
-		);
-		await expect(n8n.instanceAi.getBackgroundTaskIndicator()).toBeVisible({ timeout: 15_000 });
+			await api.runInstanceAiLivenessSweep(simulation.timeoutAt);
 
-		await api.runInstanceAiLivenessSweep(simulation.timeoutAt);
-
-		await expect(
-			n8n.instanceAi.getAssistantMessageText(
-				/Background workflow-builder task timed out after \d+ms/,
-			),
-		).toBeVisible({ timeout: 15_000 });
-		await expect(n8n.instanceAi.getBackgroundTaskIndicator()).toBeHidden({ timeout: 15_000 });
-	});
+			await expect(
+				n8n.instanceAi.getAssistantMessageText(
+					/Background workflow-builder task timed out after \d+ms/,
+				),
+			).toBeVisible({ timeout: 15_000 });
+			await expect(n8n.instanceAi.getBackgroundTaskIndicator()).toBeHidden({ timeout: 15_000 });
+		},
+	);
 });
diff --git a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-execution.spec.ts b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-execution.spec.ts
index 75009c26a18..46766021055 100644
--- a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-execution.spec.ts
+++ b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-execution.spec.ts
@@ -107,8 +107,7 @@ test.describe(
 			});
 
 			// Double-click a node to open NDV
-			const setNode = n8n.instanceAi.getPreviewNodeByName('ndv output test');
-			await setNode.dblclick();
+			await n8n.instanceAi.openPreviewNodeByName('ndv output test');
 
 			// The NDV output panel should be visible with execution data
 			await expect(n8n.instanceAi.getPreviewNdvOutputPanel()).toBeVisible({
diff --git a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-preview.spec.ts b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-preview.spec.ts
index 2126ee8e1e9..025e4966cf2 100644
--- a/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-preview.spec.ts
+++ b/packages/testing/playwright/tests/e2e/instance-ai/instance-ai-workflow-preview.spec.ts
@@ -83,8 +83,8 @@ test.describe(
 				timeout: 120_000,
 			});
 
-			// Close the preview
-			await n8n.instanceAi.getPreviewCloseButton().click();
+			// Hide the preview
+			await n8n.instanceAi.getPreviewToggleButton().click();
 
 			// Preview iframe should no longer be visible
 			await expect(n8n.instanceAi.getPreviewIframeLocator()).toBeHidden();
diff --git a/packages/testing/playwright/tests/e2e/workflows/editor/expressions/transformation.spec.ts b/packages/testing/playwright/tests/e2e/workflows/editor/expressions/transformation.spec.ts
index 5022b3c3308..7250b112cd2 100644
--- a/packages/testing/playwright/tests/e2e/workflows/editor/expressions/transformation.spec.ts
+++ b/packages/testing/playwright/tests/e2e/workflows/editor/expressions/transformation.spec.ts
@@ -111,7 +111,7 @@ test.describe(
 			await expect(n8n.ndv.getInlineExpressionEditorOutput()).toContainText(output);
 
 			await n8n.ndv.execute();
-			const valueElements = n8n.ndv.getOutputDataContainer().locator('[class*=value_]');
+			const valueElements = n8n.ndv.getOutputDataValues();
 			await expect(valueElements).toBeVisible();
 			await expect(valueElements).toContainText(output);
 		});
@@ -131,7 +131,7 @@ test.describe(
 			await expect(n8n.ndv.getInlineExpressionEditorOutput()).toContainText(output);
 
 			await n8n.ndv.execute();
-			const valueElements = n8n.ndv.getOutputDataContainer().locator('[class*=value_]');
+			const valueElements = n8n.ndv.getOutputDataValues();
 			await expect(valueElements).toBeVisible();
 			await expect(valueElements).toContainText(output);
 		});
diff --git a/packages/testing/playwright/tests/e2e/workflows/editor/subworkflows/workflow-selector.spec.ts b/packages/testing/playwright/tests/e2e/workflows/editor/subworkflows/workflow-selector.spec.ts
index 81720e37981..473ac065270 100644
--- a/packages/testing/playwright/tests/e2e/workflows/editor/subworkflows/workflow-selector.spec.ts
+++ b/packages/testing/playwright/tests/e2e/workflows/editor/subworkflows/workflow-selector.spec.ts
@@ -89,7 +89,7 @@ test.describe(
 
 			const addResourceItem = n8n.ndv.getAddResourceItem();
 			await expect(addResourceItem).toHaveCount(1);
-			await expect(addResourceItem.getByText(/Create a/)).toBeVisible();
+			await expect(n8n.ndv.getAddResourceCreateOption()).toBeVisible();
 
 			const secondPage = await n8n.start.fromNewPage(async () => {
 				await n8n.ndvComposer.createNewSubworkflow('workflowId');
diff --git a/packages/testing/playwright/tests/infrastructure/benchmarks-local/instance-ai/fixtures.ts b/packages/testing/playwright/tests/infrastructure/benchmarks-local/instance-ai/fixtures.ts
index 49e72f23186..e01ae366b7f 100644
--- a/packages/testing/playwright/tests/infrastructure/benchmarks-local/instance-ai/fixtures.ts
+++ b/packages/testing/playwright/tests/infrastructure/benchmarks-local/instance-ai/fixtures.ts
@@ -17,11 +17,10 @@ export const instanceAiTestConfig = {
 } as const;
 
 export const test = base.extend<InstanceAiMemoryFixtures>({
-	instanceAiDriver: async ({ n8n, backendUrl, services }, use) => {
+	instanceAiDriver: async ({ n8n, backendUrl }, use) => {
 		const config: InstanceAiDriverConfig = {
 			n8n,
 			baseUrl: backendUrl,
-			metrics: services.observability.metrics,
 		};
 
 		const driver = new InstanceAiDriver(config);
diff --git a/packages/testing/playwright/utils/benchmark/instance-ai-driver.ts b/packages/testing/playwright/utils/benchmark/instance-ai-driver.ts
index bd2ffbde6a6..ec9501e67b5 100644
--- a/packages/testing/playwright/utils/benchmark/instance-ai-driver.ts
+++ b/packages/testing/playwright/utils/benchmark/instance-ai-driver.ts
@@ -1,14 +1,7 @@
-import type { Page, TestInfo } from '@playwright/test';
-import type { MetricsHelper } from 'n8n-containers';
+import type { Page } from '@playwright/test';
 
 import { InstanceAiPage } from '../../pages/InstanceAiPage';
 import type { n8nPage } from '../../pages/n8nPage';
-import {
-	getStableHeap,
-	takeHeapSnapshot,
-	type StableHeapOptions,
-	type StableHeapResult,
-} from '../performance-helper';
 
 /** Lightweight prompt for warmup — exercises the instance-ai path without building a workflow. */
 export const WARMUP_PROMPT = 'List my current credentials.';
@@ -42,8 +35,6 @@ export interface InstanceAiDriverConfig {
 	n8n: n8nPage;
 	/** Backend base URL for REST API calls (GC, snapshots, thread management) */
 	baseUrl: string;
-	/** VictoriaMetrics helper for heap queries */
-	metrics: MetricsHelper;
 }
 
 export interface RunParallelOptions {
@@ -74,14 +65,12 @@ export interface TabRunResult {
 export class InstanceAiDriver {
 	private readonly n8n: n8nPage;
 	private readonly baseUrl: string;
-	private readonly metrics: MetricsHelper;
 	private createdThreadIds: string[] = [];
 	private openedPages: Page[] = [];
 
 	constructor(config: InstanceAiDriverConfig) {
 		this.n8n = config.n8n;
 		this.baseUrl = config.baseUrl;
-		this.metrics = config.metrics;
 	}
 
 	/**
@@ -259,14 +248,6 @@ export class InstanceAiDriver {
 		this.createdThreadIds = this.createdThreadIds.filter((id) => id !== threadId);
 	}
 
-	/** Delete all threads created by this driver instance. */
-	async deleteAllThreads(): Promise<void> {
-		const threadIds = [...this.createdThreadIds];
-		for (const threadId of threadIds) {
-			await this.deleteThread(threadId);
-		}
-	}
-
 	/** Delete all workflows via the REST API to prevent cross-round interference. */
 	async deleteAllWorkflows(): Promise<void> {
 		const cookies = await this.n8n.page.context().cookies();
@@ -298,16 +279,6 @@ export class InstanceAiDriver {
 		await this.deleteAllWorkflows();
 	}
 
-	/** Take a stable server-side heap measurement (triggers GC + polls VictoriaMetrics). */
-	async measureHeap(options?: StableHeapOptions): Promise<StableHeapResult> {
-		return await getStableHeap(this.baseUrl, this.metrics, options);
-	}
-
-	/** Trigger a V8 heap snapshot on the server. */
-	async snapshot(testInfo: TestInfo, label: string): Promise<void> {
-		await takeHeapSnapshot(this.baseUrl, testInfo, label);
-	}
-
 	private extractThreadId(page: Page): string {
 		const url = new URL(page.url());
 		const match = url.pathname.match(/\/instance-ai\/([0-9a-f-]+)/);
diff --git a/packages/workflow/src/node-helpers.ts b/packages/workflow/src/node-helpers.ts
index 1ebbe94e519..37390c228e1 100644
--- a/packages/workflow/src/node-helpers.ts
+++ b/packages/workflow/src/node-helpers.ts
@@ -129,7 +129,7 @@ export const cronNodeOptions: INodePropertyCollection[] = [
 					},
 				},
 				default: 0,
-				description: 'The minute of the day to trigger',
+				description: 'The minute past the hour to trigger (0-59)',
 			},
 			{
 				displayName: 'Day of Month',