0
# Workflow Management
1

2
Core workflow operations for creating, editing, executing, and managing automated workflows in the n8n Editor UI.
3

4
## Capabilities
5

6
### Workflow Store
7

8
Central Pinia store for managing workflow state and operations.
9

10
```typescript { .api }
11
/**
12
 * Main workflow store providing centralized workflow state management
13
 */
14
interface WorkflowsStore {
15
  // State properties
16
  workflow: IWorkflowDb;
17
  workflowObject: Workflow;
18
  activeWorkflows: string[];
19
  workflowExecutionData: IExecutionResponse | null;
20
  nodeMetadata: NodeMetadataMap;
21
  chatMessages: string[];
22
  
23
  // Computed getters
24
  workflowName: string;
25
  workflowId: string;
26
  allNodes: INodeUi[];
27
  isNewWorkflow: boolean;
28
  isWorkflowRunning: boolean;
29
  nodesIssuesExist: boolean;
30
  
31
  // Actions - Core Workflow Operations
32
  setWorkflow(workflow: IWorkflowDb): void;
33
  resetWorkflow(): void;
34
  resetState(): void;
35
  createNewWorkflow(data: WorkflowDataCreate): Promise<IWorkflowDb>;
36
  updateWorkflow(id: string, data: WorkflowDataUpdate): Promise<IWorkflowDb>;
37
  fetchWorkflow(id: string): Promise<IWorkflowDb>;
38
  fetchAllWorkflows(): Promise<IWorkflowDb[]>;
39
  fetchWorkflowsPage(params: WorkflowSearchParams): Promise<IWorkflowsListResponse>;
40
  deleteWorkflow(id: string): Promise<void>;
41
  archiveWorkflow(id: string): Promise<void>;
42
  unarchiveWorkflow(id: string): Promise<void>;
43
  
44
  // Actions - Workflow State Management
45
  setWorkflowActive(targetWorkflowId: string): void;
46
  setWorkflowInactive(targetWorkflowId: string): void;
47
  setWorkflowName(data: { newName: string; setStateDirty: boolean }): void;
48
  setWorkflowSettings(settings: IWorkflowSettings): void;
49
  setWorkflowPinData(data: IPinData): void;
50
  setWorkflowTagIds(tags: string[]): void;
51
  setWorkflowScopes(scopes: Scope[]): void;
52
  setWorkflowMetadata(metadata: WorkflowMetadata): void;
53
  
54
  // Actions - Node Operations
55
  addNode(node: INodeUi): void;
56
  removeNode(node: INodeUi): void;
57
  removeNodeById(id: string): void;
58
  updateNodeAtIndex(index: number, node: INodeUi): void;
59
  updateNodeProperties(data: INodeUpdatePropertiesInformation): void;
60
  setNodeValue(updateInfo: IUpdateInformation): void;
61
  setNodeParameters(updateInfo: IUpdateInformation): void;
62
  setNodePositionById(id: string, position: XYPosition): void;
63
  
64
  // Actions - Connection Operations
65
  addConnection(data: { connection: IConnection[] }): void;
66
  removeConnection(data: { connection: IConnection[] }): void;
67
  removeAllConnections(): void;
68
  removeAllNodeConnection(data: { node: INodeUi }): void;
69
  
70
  // Actions - Execution Operations
71
  runWorkflow(data: IStartRunData): Promise<IExecutionPushResponse>;
72
  setWorkflowExecutionData(executionData: IExecutionResponse | null): void;
73
  fetchExecutionDataById(executionId: string): Promise<IExecutionFlattedResponse>;
74
  deleteExecution(executionId: string): Promise<void>;
75
  
76
  // Actions - Pin Data Operations
77
  pinData(payload: { node: INodeUi; data: INodeExecutionData[] }): void;
78
  unpinData(payload: { node: INodeUi }): void;
79
}
80

81
/**
82
 * Access the workflows store instance
83
 */
84
function useWorkflowsStore(): WorkflowsStore;
85
```
86

87
**Usage Example:**
88

89
```typescript
90
import { useWorkflowsStore } from '@/stores/workflows.store';
91

92
const workflowsStore = useWorkflowsStore();
93

94
// Create new workflow
95
const workflow = await workflowsStore.createNewWorkflow({
96
  name: 'Data Processing Pipeline',
97
  nodes: [],
98
  connections: {}
99
});
100

101
// Add a node
102
workflowsStore.addNode({
103
  id: 'start-node',
104
  name: 'When clicking "Test workflow"',
105
  type: 'n8n-nodes-base.manualTrigger',
106
  position: [240, 300],
107
  parameters: {}
108
});
109

110
// Execute workflow
111
const workflowData = workflowsStore.getWorkflowDataToSave();
112
await workflowsStore.runWorkflow({
113
  workflowData: workflowData
114
});
115
```
116

117
### Workflow Creation
118

119
Create new workflows with initial configuration.
120

121
```typescript { .api }
122
/**
123
 * Create a new workflow with specified configuration
124
 * @param data - Workflow creation data
125
 * @returns Promise resolving to created workflow
126
 */
127
function createNewWorkflow(data: WorkflowDataCreate): Promise<IWorkflowDb>;
128

129
interface WorkflowDataCreate {
130
  name: string;
131
  nodes?: INodeUi[];
132
  connections?: IConnections;
133
  settings?: IWorkflowSettings;
134
  tags?: string[];
135
  meta?: WorkflowMetadata;
136
}
137

138
interface WorkflowMetadata {
139
  templateId?: string;
140
  instanceId?: string;
141
  templateCredsSetupCompleted?: boolean;
142
  category?: string;
143
}
144
```
145

146
### Workflow Updates
147

148
Update existing workflows with new data.
149

150
```typescript { .api }
151
/**
152
 * Update an existing workflow
153
 * @param id - Workflow ID to update
154
 * @param data - Updated workflow data
155
 * @returns Promise resolving to updated workflow
156
 */
157
function updateWorkflow(id: string, data: WorkflowDataUpdate): Promise<IWorkflowDb>;
158

159
interface WorkflowDataUpdate {
160
  name?: string;
161
  nodes?: INodeUi[];
162
  connections?: IConnections;
163
  settings?: IWorkflowSettings;
164
  tags?: string[];
165
  active?: boolean;
166
  pinData?: IPinData;
167
  versionId?: string;
168
  meta?: WorkflowMetadata;
169
}
170
```
171

172
### Node Management
173

174
Add, remove, and modify nodes within workflows.
175

176
```typescript { .api }
177
/**
178
 * Add a new node to the current workflow
179
 * @param node - Node data to add
180
 */
181
function addNode(node: INodeUi): void;
182

183
/**
184
 * Remove a node from the current workflow
185
 * @param node - Node to remove
186
 */
187
function removeNode(node: INodeUi): void;
188

189
/**
190
 * Update a node parameter value
191
 * @param updateInfo - Parameter update information
192
 */
193
function setNodeValue(updateInfo: IUpdateInformation): void;
194

195
interface INodeUi extends INode {
196
  position: XYPosition;
197
  color?: string;
198
  notes?: string;
199
  issues?: INodeIssues;
200
  name: string;
201
  pinData?: IDataObject;
202
  draggable?: boolean;
203
}
204

205
interface IUpdateInformation<T = NodeParameterValueType> {
206
  name: string;        // Node name
207
  key?: string;        // Parameter key path
208
  value: T;           // New parameter value
209
  node?: string;      // Target node name
210
  oldValue?: string | number;
211
  type?: 'optionsOrderChanged';
212
}
213
```
214

215
### Connection Management
216

217
Manage connections between workflow nodes.
218

219
```typescript { .api }
220
/**
221
 * Add a connection between nodes
222
 * @param data - Connection data
223
 */
224
function addConnection(data: { connection: IConnection[] }): void;
225

226
/**
227
 * Remove a connection between nodes
228
 * @param data - Connection data to remove
229
 */
230
function removeConnection(data: { connection: IConnection[] }): void;
231

232
interface IConnection {
233
  node: string;
234
  type: NodeConnectionType;
235
  index: number;
236
}
237

238
interface IConnections {
239
  [key: string]: {
240
    [key: string]: IConnection[][];
241
  };
242
}
243
```
244

245
### Workflow Execution
246

247
Execute workflows and manage execution state.
248

249
```typescript { .api }
250
/**
251
 * Execute a workflow with specified configuration
252
 * @param data - Execution configuration
253
 * @returns Promise resolving to execution response
254
 */
255
function runWorkflow(data: IStartRunData): Promise<IExecutionPushResponse>;
256

257
interface IStartRunData {
258
  workflowData: WorkflowData;
259
  startNodes?: StartNodeData[];
260
  destinationNode?: string;
261
  runData?: IRunData;
262
  dirtyNodeNames?: string[];
263
  triggerToStartFrom?: {
264
    name: string;
265
    data?: ITaskData;
266
  };
267
}
268

269
interface IExecutionPushResponse {
270
  executionId?: string;
271
  waitingForWebhook?: boolean;
272
}
273

274
interface StartNodeData {
275
  name: string;
276
  sourceData?: ITaskData;
277
}
278
```
279

280
**Usage Example:**
281

282
```typescript
283
// Execute workflow from specific node
284
await workflowsStore.runWorkflow({
285
  workflowData: workflowsStore.workflow,
286
  startNodes: [{ name: 'HTTP Request' }],
287
  destinationNode: 'Data Processing'
288
});
289

290
// Execute with custom run data
291
await workflowsStore.runWorkflow({
292
  workflowData: workflowsStore.workflow,
293
  runData: {
294
    'HTTP Request': [
295
      {
296
        startTime: new Date().getTime(),
297
        executionTime: 0,
298
        data: { main: [[{ json: { id: 1, name: 'test' } }]] }
299
      }
300
    ]
301
  }
302
});
303
```
304

305
### Workflow Helpers
306

307
Utility functions for common workflow operations.
308

309
```typescript { .api }
310
/**
311
 * Composable providing workflow helper functions
312
 */
313
function useWorkflowHelpers(): {
314
  getWorkflowDataToSave(): IWorkflowDataUpdate;
315
  saveCurrentWorkflow(options?: { tags?: string[] }): Promise<void>;
316
  getCurrentWorkflow(copyData?: boolean): Workflow;
317
  getWorkflowDataToSave(): IWorkflowDataUpdate;
318
};
319

320
/**
321
 * Get workflow data prepared for saving
322
 * @returns Workflow data ready for API submission
323
 */
324
function getWorkflowDataToSave(): IWorkflowDataUpdate;
325

326
/**
327
 * Save the current workflow to backend
328
 * @param options - Save options including tags
329
 */
330
function saveCurrentWorkflow(options?: { tags?: string[] }): Promise<void>;
331

332
/**
333
 * Get current workflow object instance
334
 * @param copyData - Whether to copy workflow data
335
 * @returns Workflow execution object
336
 */
337
function getCurrentWorkflow(copyData?: boolean): Workflow;
338
```
339

340
### Workflow Settings
341

342
Configure workflow execution and behavior settings.
343

344
```typescript { .api }
345
interface IWorkflowSettings extends IWorkflowSettingsWorkflow {
346
  errorWorkflow?: string;
347
  timezone?: string;
348
  executionTimeout?: number;
349
  maxExecutionTimeout?: number;
350
  callerIds?: string;
351
  callerPolicy?: WorkflowSettings.CallerPolicy;
352
  executionOrder: NonNullable<IWorkflowSettingsWorkflow['executionOrder']>;
353
}
354

355
interface IWorkflowSettingsWorkflow {
356
  executionOrder: 'v0' | 'v1';
357
  saveDataErrorExecution: 'all' | 'none';
358
  saveDataSuccessExecution: 'all' | 'none';
359
  saveManualExecutions: boolean;
360
  saveExecutionProgress: boolean;
361
  callerPolicy?: string;
362
  callerIds?: string;
363
}
364
```
365

366
## Types
367

368
```typescript { .api }
369
interface IWorkflowDb {
370
  id: string;
371
  name: string;
372
  active: boolean;
373
  isArchived: boolean;
374
  createdAt: number | string;
375
  updatedAt: number | string;
376
  nodes: INodeUi[];
377
  connections: IConnections;
378
  settings?: IWorkflowSettings;
379
  tags?: ITag[] | string[];
380
  pinData?: IPinData;
381
  sharedWithProjects?: ProjectSharingData[];
382
  homeProject?: ProjectSharingData;
383
  scopes?: Scope[];
384
  versionId: string;
385
  usedCredentials?: IUsedCredential[];
386
  meta?: WorkflowMetadata;
387
}
388

389
interface NodeMetadataMap {
390
  [nodeName: string]: INodeMetadata;
391
}
392

393
interface INodeMetadata {
394
  parametersLastUpdatedAt?: number;
395
  pinnedDataLastRemovedAt?: number;
396
  pristine: boolean;
397
}
398

399
type WorkflowTitleStatus = 'EXECUTING' | 'IDLE' | 'ERROR' | 'DEBUG';
400
```