Skip to main content
Glama

n8n_delete_workflow

Destructive

Permanently delete a workflow from the n8n automation platform. This action cannot be undone and requires the workflow ID.

Instructions

Permanently delete a workflow. This action cannot be undone.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
idYesWorkflow ID to delete

Implementation Reference

  • Handler function that executes the n8n_delete_workflow tool. Validates input ID, uses N8nApiClient to delete the workflow, handles errors, and returns formatted response.
    export async function handleDeleteWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
      try {
        const client = ensureApiConfigured(context);
        const { id } = z.object({ id: z.string() }).parse(args);
    
        const deleted = await client.deleteWorkflow(id);
    
        return {
          success: true,
          data: {
            id: deleted?.id || id,
            name: deleted?.name,
            deleted: true
          },
          message: `Workflow "${deleted?.name || id}" deleted successfully.`
        };
      } catch (error) {
        if (error instanceof z.ZodError) {
          return {
            success: false,
            error: 'Invalid input',
            details: { errors: error.errors }
          };
        }
        
        if (error instanceof N8nApiError) {
          return {
            success: false,
            error: getUserFriendlyErrorMessage(error),
            code: error.code
          };
        }
        
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Unknown error occurred'
        };
      }
    }
  • Tool definition including name, description, and input schema (workflow ID required). Part of n8nManagementTools array used for registration.
    {
      name: 'n8n_delete_workflow',
      description: `Permanently delete a workflow. This action cannot be undone.`,
      inputSchema: {
        type: 'object',
        properties: {
          id: { 
            type: 'string', 
            description: 'Workflow ID to delete' 
          }
        },
        required: ['id']
      }
    },
  • The n8nManagementTools array registers all n8n management tools including n8n_delete_workflow. Imported and conditionally added to tool list in http-server.ts when API is configured.
    export const n8nManagementTools: ToolDefinition[] = [
      // Workflow Management Tools
      {
        name: 'n8n_create_workflow',
        description: `Create workflow. Requires: name, nodes[], connections{}. Created inactive. Returns workflow with ID.`,
        inputSchema: {
          type: 'object',
          properties: {
            name: { 
              type: 'string', 
              description: 'Workflow name (required)' 
            },
            nodes: { 
              type: 'array', 
              description: 'Array of workflow nodes. Each node must have: id, name, type, typeVersion, position, and parameters',
              items: {
                type: 'object',
                required: ['id', 'name', 'type', 'typeVersion', 'position', 'parameters'],
                properties: {
                  id: { type: 'string' },
                  name: { type: 'string' },
                  type: { type: 'string' },
                  typeVersion: { type: 'number' },
                  position: { 
                    type: 'array',
                    items: { type: 'number' },
                    minItems: 2,
                    maxItems: 2
                  },
                  parameters: { type: 'object' },
                  credentials: { type: 'object' },
                  disabled: { type: 'boolean' },
                  notes: { type: 'string' },
                  continueOnFail: { type: 'boolean' },
                  retryOnFail: { type: 'boolean' },
                  maxTries: { type: 'number' },
                  waitBetweenTries: { type: 'number' }
                }
              }
            },
            connections: { 
              type: 'object', 
              description: 'Workflow connections object. Keys are source node IDs, values define output connections' 
            },
            settings: {
              type: 'object',
              description: 'Optional workflow settings (execution order, timezone, error handling)',
              properties: {
                executionOrder: { type: 'string', enum: ['v0', 'v1'] },
                timezone: { type: 'string' },
                saveDataErrorExecution: { type: 'string', enum: ['all', 'none'] },
                saveDataSuccessExecution: { type: 'string', enum: ['all', 'none'] },
                saveManualExecutions: { type: 'boolean' },
                saveExecutionProgress: { type: 'boolean' },
                executionTimeout: { type: 'number' },
                errorWorkflow: { type: 'string' }
              }
            }
          },
          required: ['name', 'nodes', 'connections']
        }
      },
      {
        name: 'n8n_get_workflow',
        description: `Get workflow by ID with different detail levels. Use mode='full' for complete workflow, 'details' for metadata+stats, 'structure' for nodes/connections only, 'minimal' for id/name/active/tags.`,
        inputSchema: {
          type: 'object',
          properties: {
            id: {
              type: 'string',
              description: 'Workflow ID'
            },
            mode: {
              type: 'string',
              enum: ['full', 'details', 'structure', 'minimal'],
              default: 'full',
              description: 'Detail level: full=complete workflow, details=full+execution stats, structure=nodes/connections topology, minimal=metadata only'
            }
          },
          required: ['id']
        }
      },
      {
        name: 'n8n_update_full_workflow',
        description: `Full workflow update. Requires complete nodes[] and connections{}. For incremental use n8n_update_partial_workflow.`,
        inputSchema: {
          type: 'object',
          properties: {
            id: { 
              type: 'string', 
              description: 'Workflow ID to update' 
            },
            name: { 
              type: 'string', 
              description: 'New workflow name' 
            },
            nodes: { 
              type: 'array', 
              description: 'Complete array of workflow nodes (required if modifying workflow structure)',
              items: {
                type: 'object',
                additionalProperties: true
              }
            },
            connections: { 
              type: 'object', 
              description: 'Complete connections object (required if modifying workflow structure)' 
            },
            settings: { 
              type: 'object', 
              description: 'Workflow settings to update' 
            }
          },
          required: ['id']
        }
      },
      {
        name: 'n8n_update_partial_workflow',
        description: `Update workflow incrementally with diff operations. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, updateSettings, updateName, add/removeTag. See tools_documentation("n8n_update_partial_workflow", "full") for details.`,
        inputSchema: {
          type: 'object',
          additionalProperties: true,  // Allow any extra properties Claude Desktop might add
          properties: {
            id: { 
              type: 'string', 
              description: 'Workflow ID to update' 
            },
            operations: {
              type: 'array',
              description: 'Array of diff operations to apply. Each operation must have a "type" field and relevant properties for that operation type.',
              items: {
                type: 'object',
                additionalProperties: true
              }
            },
            validateOnly: {
              type: 'boolean',
              description: 'If true, only validate operations without applying them'
            },
            continueOnError: {
              type: 'boolean',
              description: 'If true, apply valid operations even if some fail (best-effort mode). Returns applied and failed operation indices. Default: false (atomic)'
            }
          },
          required: ['id', 'operations']
        }
      },
      {
        name: 'n8n_delete_workflow',
        description: `Permanently delete a workflow. This action cannot be undone.`,
        inputSchema: {
          type: 'object',
          properties: {
            id: { 
              type: 'string', 
              description: 'Workflow ID to delete' 
            }
          },
          required: ['id']
        }
      },
      {
        name: 'n8n_list_workflows',
        description: `List workflows (minimal metadata only). Returns id/name/active/dates/tags. Check hasMore/nextCursor for pagination.`,
        inputSchema: {
          type: 'object',
          properties: {
            limit: { 
              type: 'number', 
              description: 'Number of workflows to return (1-100, default: 100)' 
            },
            cursor: { 
              type: 'string', 
              description: 'Pagination cursor from previous response' 
            },
            active: { 
              type: 'boolean', 
              description: 'Filter by active status' 
            },
            tags: { 
              type: 'array', 
              items: { type: 'string' },
              description: 'Filter by tags (exact match)' 
            },
            projectId: { 
              type: 'string', 
              description: 'Filter by project ID (enterprise feature)' 
            },
            excludePinnedData: { 
              type: 'boolean', 
              description: 'Exclude pinned data from response (default: true)' 
            }
          }
        }
      },
      {
        name: 'n8n_validate_workflow',
        description: `Validate workflow by ID. Checks nodes, connections, expressions. Returns errors/warnings/suggestions.`,
        inputSchema: {
          type: 'object',
          properties: {
            id: { 
              type: 'string', 
              description: 'Workflow ID to validate' 
            },
            options: {
              type: 'object',
              description: 'Validation options',
              properties: {
                validateNodes: { 
                  type: 'boolean', 
                  description: 'Validate node configurations (default: true)' 
                },
                validateConnections: { 
                  type: 'boolean', 
                  description: 'Validate workflow connections (default: true)' 
                },
                validateExpressions: { 
                  type: 'boolean', 
                  description: 'Validate n8n expressions (default: true)' 
                },
                profile: { 
                  type: 'string', 
                  enum: ['minimal', 'runtime', 'ai-friendly', 'strict'],
                  description: 'Validation profile to use (default: runtime)' 
                }
              }
            }
          },
          required: ['id']
        }
      },
      {
        name: 'n8n_autofix_workflow',
        description: `Automatically fix common workflow validation errors. Preview fixes or apply them. Fixes expression format, typeVersion, error output config, webhook paths.`,
        inputSchema: {
          type: 'object',
          properties: {
            id: {
              type: 'string',
              description: 'Workflow ID to fix'
            },
            applyFixes: {
              type: 'boolean',
              description: 'Apply fixes to workflow (default: false - preview mode)'
            },
            fixTypes: {
              type: 'array',
              description: 'Types of fixes to apply (default: all)',
              items: {
                type: 'string',
                enum: ['expression-format', 'typeversion-correction', 'error-output-config', 'node-type-correction', 'webhook-missing-path', 'typeversion-upgrade', 'version-migration']
              }
            },
            confidenceThreshold: {
              type: 'string',
              enum: ['high', 'medium', 'low'],
              description: 'Minimum confidence level for fixes (default: medium)'
            },
            maxFixes: {
              type: 'number',
              description: 'Maximum number of fixes to apply (default: 50)'
            }
          },
          required: ['id']
        }
      },
    
      // Execution Management Tools
      {
        name: 'n8n_test_workflow',
        description: `Test/trigger workflow execution. Auto-detects trigger type (webhook/form/chat). Supports: webhook (HTTP), form (fields), chat (message). Note: Only workflows with these trigger types can be executed externally.`,
        inputSchema: {
          type: 'object',
          properties: {
            workflowId: {
              type: 'string',
              description: 'Workflow ID to execute (required)'
            },
            triggerType: {
              type: 'string',
              enum: ['webhook', 'form', 'chat'],
              description: 'Trigger type. Auto-detected if not specified. Workflow must have a matching trigger node.'
            },
            // Webhook options
            httpMethod: {
              type: 'string',
              enum: ['GET', 'POST', 'PUT', 'DELETE'],
              description: 'For webhook: HTTP method (default: from workflow config or POST)'
            },
            webhookPath: {
              type: 'string',
              description: 'For webhook: override the webhook path'
            },
            // Chat options
            message: {
              type: 'string',
              description: 'For chat: message to send (required for chat triggers)'
            },
            sessionId: {
              type: 'string',
              description: 'For chat: session ID for conversation continuity'
            },
            // Common options
            data: {
              type: 'object',
              description: 'Input data/payload for webhook, form fields, or execution data'
            },
            headers: {
              type: 'object',
              description: 'Custom HTTP headers'
            },
            timeout: {
              type: 'number',
              description: 'Timeout in ms (default: 120000)'
            },
            waitForResponse: {
              type: 'boolean',
              description: 'Wait for workflow completion (default: true)'
            }
          },
          required: ['workflowId']
        }
      },
      {
        name: 'n8n_executions',
        description: `Manage workflow executions: get details, list, or delete. Use action='get' with id for execution details, action='list' for listing executions, action='delete' to remove execution record.`,
        inputSchema: {
          type: 'object',
          properties: {
            action: {
              type: 'string',
              enum: ['get', 'list', 'delete'],
              description: 'Operation: get=get execution details, list=list executions, delete=delete execution'
            },
            // For action='get' and action='delete'
            id: {
              type: 'string',
              description: 'Execution ID (required for action=get or action=delete)'
            },
            // For action='get' - detail level
            mode: {
              type: 'string',
              enum: ['preview', 'summary', 'filtered', 'full', 'error'],
              description: 'For action=get: preview=structure only, summary=2 items (default), filtered=custom, full=all data, error=optimized error debugging'
            },
            nodeNames: {
              type: 'array',
              items: { type: 'string' },
              description: 'For action=get with mode=filtered: filter to specific nodes by name'
            },
            itemsLimit: {
              type: 'number',
              description: 'For action=get with mode=filtered: items per node (0=structure, 2=default, -1=unlimited)'
            },
            includeInputData: {
              type: 'boolean',
              description: 'For action=get: include input data in addition to output (default: false)'
            },
            // Error mode specific parameters
            errorItemsLimit: {
              type: 'number',
              description: 'For action=get with mode=error: sample items from upstream node (default: 2, max: 100)'
            },
            includeStackTrace: {
              type: 'boolean',
              description: 'For action=get with mode=error: include full stack trace (default: false, shows truncated)'
            },
            includeExecutionPath: {
              type: 'boolean',
              description: 'For action=get with mode=error: include execution path leading to error (default: true)'
            },
            fetchWorkflow: {
              type: 'boolean',
              description: 'For action=get with mode=error: fetch workflow for accurate upstream detection (default: true)'
            },
            // For action='list'
            limit: {
              type: 'number',
              description: 'For action=list: number of executions to return (1-100, default: 100)'
            },
            cursor: {
              type: 'string',
              description: 'For action=list: pagination cursor from previous response'
            },
            workflowId: {
              type: 'string',
              description: 'For action=list: filter by workflow ID'
            },
            projectId: {
              type: 'string',
              description: 'For action=list: filter by project ID (enterprise feature)'
            },
            status: {
              type: 'string',
              enum: ['success', 'error', 'waiting'],
              description: 'For action=list: filter by execution status'
            },
            includeData: {
              type: 'boolean',
              description: 'For action=list: include execution data (default: false)'
            }
          },
          required: ['action']
        }
      },
    
      // System Tools
      {
        name: 'n8n_health_check',
        description: `Check n8n instance health and API connectivity. Use mode='diagnostic' for detailed troubleshooting with env vars and tool status.`,
        inputSchema: {
          type: 'object',
          properties: {
            mode: {
              type: 'string',
              enum: ['status', 'diagnostic'],
              description: 'Mode: "status" (default) for quick health check, "diagnostic" for detailed debug info including env vars and tool status',
              default: 'status'
            },
            verbose: {
              type: 'boolean',
              description: 'Include extra details in diagnostic mode (default: false)'
            }
          }
        }
      },
      {
        name: 'n8n_workflow_versions',
        description: `Manage workflow version history, rollback, and cleanup. Six modes:
    - list: Show version history for a workflow
    - get: Get details of specific version
    - rollback: Restore workflow to previous version (creates backup first)
    - delete: Delete specific version or all versions for a workflow
    - prune: Manually trigger pruning to keep N most recent versions
    - truncate: Delete ALL versions for ALL workflows (requires confirmation)`,
        inputSchema: {
          type: 'object',
          properties: {
            mode: {
              type: 'string',
              enum: ['list', 'get', 'rollback', 'delete', 'prune', 'truncate'],
              description: 'Operation mode'
            },
            workflowId: {
              type: 'string',
              description: 'Workflow ID (required for list, rollback, delete, prune)'
            },
            versionId: {
              type: 'number',
              description: 'Version ID (required for get mode and single version delete, optional for rollback)'
            },
            limit: {
              type: 'number',
              default: 10,
              description: 'Max versions to return in list mode'
            },
            validateBefore: {
              type: 'boolean',
              default: true,
              description: 'Validate workflow structure before rollback'
            },
            deleteAll: {
              type: 'boolean',
              default: false,
              description: 'Delete all versions for workflow (delete mode only)'
            },
            maxVersions: {
              type: 'number',
              default: 10,
              description: 'Keep N most recent versions (prune mode only)'
            },
            confirmTruncate: {
              type: 'boolean',
              default: false,
              description: 'REQUIRED: Must be true to truncate all versions (truncate mode only)'
            }
          },
          required: ['mode']
        }
      },
    
      // Template Deployment Tool
      {
        name: 'n8n_deploy_template',
        description: `Deploy a workflow template from n8n.io directly to your n8n instance. Deploys first, then auto-fixes common issues (expression format, typeVersions). Returns workflow ID, required credentials, and fixes applied.`,
        inputSchema: {
          type: 'object',
          properties: {
            templateId: {
              type: 'number',
              description: 'Template ID from n8n.io (required)'
            },
            name: {
              type: 'string',
              description: 'Custom workflow name (default: template name)'
            },
            autoUpgradeVersions: {
              type: 'boolean',
              default: true,
              description: 'Automatically upgrade node typeVersions to latest supported (default: true)'
            },
            autoFix: {
              type: 'boolean',
              default: true,
              description: 'Auto-apply fixes after deployment for expression format issues, missing = prefix, etc. (default: true)'
            },
            stripCredentials: {
              type: 'boolean',
              default: true,
              description: 'Remove credential references from nodes - user configures in n8n UI (default: true)'
            }
          },
          required: ['templateId']
        }
      }
    ];
  • Helper function getN8nApiClient used by handler to obtain API client instance with caching support.
    export function getN8nApiClient(context?: InstanceContext): N8nApiClient | null {
      // If context provided with n8n config, use instance-specific client
      if (context?.n8nApiUrl && context?.n8nApiKey) {
        // Validate context before using
        const validation = validateInstanceContext(context);
        if (!validation.valid) {
          logger.warn('Invalid instance context provided', {
            instanceId: context.instanceId,
            errors: validation.errors
          });
          return null;
        }
        // Create secure hash of credentials for cache key using memoization
        const cacheKey = createCacheKey(
          `${context.n8nApiUrl}:${context.n8nApiKey}:${context.instanceId || ''}`
        );
    
        // Check cache first
        if (instanceClients.has(cacheKey)) {
          cacheMetrics.recordHit();
          return instanceClients.get(cacheKey) || null;
        }
    
        cacheMetrics.recordMiss();
    
        // Check if already being created (simple lock check)
        if (cacheMutex.isLocked(cacheKey)) {
          // Wait briefly and check again
          const waitTime = 100; // 100ms
          const start = Date.now();
          while (cacheMutex.isLocked(cacheKey) && (Date.now() - start) < 1000) {
            // Busy wait for up to 1 second
          }
          // Check if it was created while waiting
          if (instanceClients.has(cacheKey)) {
            cacheMetrics.recordHit();
            return instanceClients.get(cacheKey) || null;
          }
        }
    
        const config = getN8nApiConfigFromContext(context);
        if (config) {
          // Sanitized logging - never log API keys
          logger.info('Creating instance-specific n8n API client', {
            url: config.baseUrl.replace(/^(https?:\/\/[^\/]+).*/, '$1'), // Only log domain
            instanceId: context.instanceId,
            cacheKey: cacheKey.substring(0, 8) + '...' // Only log partial hash
          });
    
          const client = new N8nApiClient(config);
          instanceClients.set(cacheKey, client);
          cacheMetrics.recordSet();
          cacheMetrics.updateSize(instanceClients.size, instanceClients.max);
          return client;
        }
    
        return null;
      }
    
      // Fall back to default singleton from environment
      logger.info('Falling back to environment configuration for n8n API client');
      const config = getN8nApiConfig();
    
      if (!config) {
        if (defaultApiClient) {
          logger.info('n8n API configuration removed, clearing default client');
          defaultApiClient = null;
          lastDefaultConfigUrl = null;
        }
        return null;
      }
    
      // Check if config has changed
      if (!defaultApiClient || lastDefaultConfigUrl !== config.baseUrl) {
        logger.info('n8n API client initialized from environment', { url: config.baseUrl });
        defaultApiClient = new N8nApiClient(config);
        lastDefaultConfigUrl = config.baseUrl;
      }
    
      return defaultApiClient;
    }
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds valuable behavioral context beyond annotations by explicitly stating the permanence and irreversibility of the deletion, which reinforces the destructiveHint annotation. It doesn't contradict annotations (destructiveHint=true aligns with 'Permanently delete'), and provides additional warning that enhances safety awareness for the agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description consists of two concise sentences that are front-loaded with the core action and follow with critical behavioral warning. Every word serves a clear purpose with zero redundancy, making it highly efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's destructive nature, the description provides sufficient context about the irreversible action, complementing the annotations well. However, without an output schema, it doesn't describe what happens after deletion (e.g., confirmation message, error handling), leaving a minor gap in completeness for a destructive operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 100% schema description coverage, the input schema already fully documents the single 'id' parameter. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation without providing extra semantic value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Permanently delete') and resource ('a workflow'), distinguishing it from siblings like n8n_get_workflow or n8n_list_workflows. It uses precise language that leaves no ambiguity about the tool's function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool by emphasizing the irreversible nature of the action ('This action cannot be undone'), which implicitly guides usage to scenarios where permanent deletion is intended. However, it doesn't explicitly mention when not to use it or name alternative tools (e.g., for temporary deactivation).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/czlonkowski/n8n-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server