Resources & Prompts API Reference¶

interface WorkflowsResource {
  workflows: WorkflowMetadata[];
  totalCount: number;
  generatedAt: string;  // ISO 8601 timestamp
}

interface WorkflowMetadata {
  id: string;
  name: string;
  active: boolean;
  createdAt: string;
  updatedAt: string;
  nodes?: number;        // Node count
  tags?: string[];       // Tag names
}

interface ExecutionStatsResource {
  summary: {
    total: number;
    successful: number;
    failed: number;
    running: number;
    successRate: number;  // Percentage
  };
  recentExecutions: ExecutionSummary[];
  byWorkflow: WorkflowExecutionStats[];
  timeRange: {
    from: string;  // ISO 8601
    to: string;    // ISO 8601
  };
  generatedAt: string;
}

interface WorkflowExecutionStats {
  workflowId: number;
  workflowName: string;
  executions: number;
  successRate: number;
  avgDuration: number;  // Milliseconds
}

interface ScheduleTriggeredWorkflowArgs {
  workflow_name: string;        // Workflow display name
  cron_schedule: string;        // Cron expression (e.g., "0 2 * * *")
  action_description: string;   // What the workflow does
  timezone?: string;            // Timezone (default: "America/New_York")
}

const prompt = await client.getPrompt({
  name: 'schedule-triggered-workflow',
  arguments: {
    workflow_name: 'Daily Backup',
    cron_schedule: '0 2 * * *',  // 2 AM daily
    action_description: 'Backup database to S3',
    timezone: 'America/New_York'
  }
});

// Prompt returns workflow definition
const workflowDef = JSON.parse(prompt.messages[0].content.text);

// Create workflow from prompt
await client.callTool({
  name: 'create_workflow',
  arguments: workflowDef
});

interface HttpWebhookWorkflowArgs {
  workflow_name: string;            // Workflow display name
  webhook_path: string;             // URL path (e.g., "customer-signup")
  response_mode?: string;           // "onReceived" or "lastNode" (default: "onReceived")
  processing_description: string;   // What the workflow does with request
}

const prompt = await client.getPrompt({
  name: 'http-webhook-workflow',
  arguments: {
    workflow_name: 'Customer Signup Handler',
    webhook_path: 'customer-signup',
    response_mode: 'onReceived',
    processing_description: 'Validate email, send welcome email, store in database'
  }
});

const workflowDef = JSON.parse(prompt.messages[0].content.text);

await client.callTool({
  name: 'create_workflow',
  arguments: workflowDef
});

interface DataTransformationWorkflowArgs {
  workflow_name: string;                // Workflow display name
  source_description: string;           // Where data comes from
  transformation_description: string;   // How data is transformed
  destination_description: string;      // Where data goes
}

const prompt = await client.getPrompt({
  name: 'data-transformation-workflow',
  arguments: {
    workflow_name: 'Sales Data ETL',
    source_description: 'Fetch sales data from Salesforce API',
    transformation_description: 'Aggregate by region and calculate totals',
    destination_description: 'Store in PostgreSQL analytics database'
  }
});

const workflowDef = JSON.parse(prompt.messages[0].content.text);

await client.callTool({
  name: 'create_workflow',
  arguments: workflowDef
});

interface ExternalServiceIntegrationArgs {
  workflow_name: string;           // Workflow display name
  service_name: string;            // External service name (e.g., "Slack", "GitHub")
  trigger_description: string;     // What triggers the workflow
  action_description: string;      // What action to perform on service
}

const prompt = await client.getPrompt({
  name: 'external-service-integration',
  arguments: {
    workflow_name: 'GitHub Issue Notifier',
    service_name: 'Slack',
    trigger_description: 'New GitHub issue created',
    action_description: 'Send notification to #dev-team channel'
  }
});

const workflowDef = JSON.parse(prompt.messages[0].content.text);

await client.callTool({
  name: 'create_workflow',
  arguments: workflowDef
});

interface ApiDataPollingArgs {
  workflow_name: string;        // Workflow display name
  api_endpoint: string;         // API URL to poll
  poll_interval: string;        // Cron expression or interval
  data_processing: string;      // What to do with retrieved data
}

const prompt = await client.getPrompt({
  name: 'api-data-polling',
  arguments: {
    workflow_name: 'Stock Price Monitor',
    api_endpoint: 'https://api.stocks.com/prices',
    poll_interval: '*/15 * * * *',  // Every 15 minutes
    data_processing: 'Compare with threshold and send alerts if exceeded'
  }
});

const workflowDef = JSON.parse(prompt.messages[0].content.text);

await client.callTool({
  name: 'create_workflow',
  arguments: workflowDef
});

import { Client } from '@modelcontextprotocol/sdk/client/index.js';

const client = new Client({
  name: 'n8n-prompt-explorer',
  version: '1.0.0'
});

await client.connect(transport);

// List all available prompts
const prompts = await client.listPrompts();

console.log('Available workflow prompts:');
prompts.forEach(prompt => {
  console.log(`\n${prompt.name}`);
  console.log(`  Description: ${prompt.description}`);
  console.log(`  Arguments:`);
  prompt.arguments?.forEach(arg => {
    const required = arg.required ? '(required)' : '(optional)';
    console.log(`    - ${arg.name} ${required}: ${arg.description}`);
  });
});

async function generateWorkflowFromPrompt(
  promptName: string,
  args: Record<string, string>,
  instance?: string
) {
  // Get prompt with arguments
  const prompt = await client.getPrompt({
    name: promptName,
    arguments: args
  });

  // Parse workflow definition from prompt
  const workflowDef = JSON.parse(prompt.messages[0].content.text);

  // Create workflow
  const result = await client.callTool({
    name: 'create_workflow',
    arguments: {
      instance,
      ...workflowDef
    }
  });

  const workflow = JSON.parse(result.content[0].text);

  console.log(`Created workflow: ${workflow.name} (ID: ${workflow.id})`);
  return workflow;
}

// Usage
const workflow = await generateWorkflowFromPrompt(
  'http-webhook-workflow',
  {
    workflow_name: 'Order Processor',
    webhook_path: 'process-order',
    processing_description: 'Validate and store order'
  },
  'production'
);

// ✅ Good: Descriptive and specific arguments
const workflow = await generateFromPrompt('http-webhook-workflow', {
  workflow_name: 'Customer Signup Processor',
  webhook_path: 'customer-signup',
  processing_description: 'Validate email format, check for duplicates, send welcome email, store in PostgreSQL customers table'
});

// ❌ Avoid: Vague descriptions
const workflow = await generateFromPrompt('http-webhook-workflow', {
  workflow_name: 'Webhook',
  webhook_path: 'webhook',
  processing_description: 'Process data'
});

// Build reusable workflow template library
const workflowTemplates = {
  customerSignup: {
    prompt: 'http-webhook-workflow',
    args: {
      workflow_name: 'Customer Signup',
      webhook_path: 'customer-signup',
      processing_description: 'Email validation → Duplicate check → Welcome email → Database storage'
    }
  },

  dailyBackup: {
    prompt: 'schedule-triggered-workflow',
    args: {
      workflow_name: 'Daily Backup',
      cron_schedule: '0 2 * * *',
      action_description: 'Backup production database to S3',
      timezone: 'UTC'
    }
  },

  slackNotifier: {
    prompt: 'external-service-integration',
    args: {
      workflow_name: 'Error Notifier',
      service_name: 'Slack',
      trigger_description: 'Application error detected',
      action_description: 'Send alert to #ops-alerts channel'
    }
  }
};

// Generate workflows from library
for (const [name, template] of Object.entries(workflowTemplates)) {
  const workflow = await generateFromPrompt(
    template.prompt,
    template.args,
    'production'
  );
  console.log(`Created ${name}: ${workflow.id}`);
}