# 20-EXECUTIONS-API.md - Executions API Endpoints
**Версия API:** v1
**Дата документации:** 2025-12-25
**Источник:** Официальная документация n8n + анализ кода MCP сервера
---
## 📋 Содержание
1. [GET /api/v1/executions](#get-apiv1executions) - Получить список выполнений
2. [GET /api/v1/executions/{id}](#get-apiv1executionsid) - Получить конкретное выполнение
3. [DELETE /api/v1/executions/{id}](#delete-apiv1executionsid) - Удалить выполнение
4. [POST /api/v1/executions/{id}/retry](#post-apiv1executionsidretry) - Повторить failed выполнение
5. [Структура объекта Execution](#структура-объекта-execution)
6. [Примеры использования](#примеры-использования)
---
## GET /api/v1/executions
### Описание
Получить список всех выполнений workflows с возможностью фильтрации по различным параметрам. Поддерживает пагинацию для больших объемов данных.
### HTTP Метод
`GET`
### Endpoint
**Self-Hosted:**
```
<N8N_HOST>:<N8N_PORT>/<N8N_PATH>/api/v1/executions
```
**n8n Cloud:**
```
<instance>.app.n8n.cloud/api/v1/executions
```
### Параметры
#### Query Parameters (Параметры запроса)
| Параметр | Тип | Обязательный | Описание |
|----------|-----|--------------|----------|
| `includeData` | boolean | Optional | Включить полные данные выполнения в ответ (по умолчанию: false) |
| `status` | string | Optional | Фильтр по статусу: `error`, `success`, `waiting` |
| `workflowId` | string | Optional | Фильтр по ID конкретного workflow |
| `projectId` | string | Optional | Фильтр по ID проекта |
| `limit` | integer | Optional | Максимальное количество результатов (по умолчанию: 100, максимум: 250) |
| `cursor` | string | Optional | Курсор для пагинации (получается из предыдущего ответа) |
#### Request Headers (Заголовки запроса)
| Заголовок | Тип | Обязательный | Описание |
|-----------|-----|--------------|----------|
| `X-N8N-API-KEY` | string | Required | API ключ для аутентификации |
| `Accept` | string | Required | Должен быть `application/json` |
### Примеры
#### Пример запроса (curl)
**Получить все выполнения:**
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
**Получить только failed выполнения:**
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions?status=error&limit=50' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
**Получить выполнения конкретного workflow:**
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions?workflowId=123&includeData=true' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
**Пагинация (следующая страница):**
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions?limit=100&cursor=MTIzZTQ1NjctZTg5Yi0xMmQzLWE0NTYtNDI2NjE0MTc0MDA' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
#### Пример запроса (JavaScript/Node.js)
```javascript
const axios = require('axios');
// Функция для получения списка executions
async function listExecutions(filters = {}) {
try {
const response = await axios.get('https://n8n.example.com/api/v1/executions', {
params: {
includeData: filters.includeData || false,
status: filters.status, // 'error', 'success', 'waiting'
workflowId: filters.workflowId,
projectId: filters.projectId,
limit: filters.limit || 100,
cursor: filters.cursor
},
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
console.log(`Получено ${response.data.data.length} executions`);
if (response.data.nextCursor) {
console.log('Есть следующая страница, курсор:', response.data.nextCursor);
}
return response.data;
} catch (error) {
console.error('Ошибка получения executions:', error.response?.data || error.message);
throw error;
}
}
// Примеры использования
await listExecutions(); // Все выполнения
await listExecutions({ status: 'error' }); // Только failed
await listExecutions({ workflowId: '123', includeData: true }); // С полными данными
```
### Ответы
#### Success Response (200 OK)
```json
{
"data": [
{
"id": 231,
"finished": true,
"mode": "manual",
"retryOf": null,
"retrySuccessId": null,
"startedAt": "2025-12-25T10:30:00.000Z",
"stoppedAt": "2025-12-25T10:30:15.000Z",
"workflowId": 123,
"waitTill": null,
"customData": {},
"data": {
"resultData": {
"runData": {
"Start": [...],
"HTTP Request": [...]
},
"lastNodeExecuted": "HTTP Request"
},
"workflowData": {
"name": "My Workflow",
"nodes": [...],
"connections": {...},
"active": true
}
}
}
],
"nextCursor": "MTIzZTQ1NjctZTg5Yi0xMmQzLWE0NTYtNDI2NjE0MTc0MDA"
}
```
**Поля ответа:**
| Поле | Тип | Описание |
|------|-----|----------|
| `data` | array | Массив объектов Execution (см. [Структура объекта Execution](#структура-объекта-execution)) |
| `nextCursor` | string | Курсор для получения следующей страницы (отсутствует на последней странице) |
#### Error Responses
**400 Bad Request** - Неверные параметры запроса
```json
{
"error": "Invalid status value. Must be 'error', 'success', or 'waiting'"
}
```
**401 Unauthorized** - Неверный или отсутствующий API ключ
```json
{
"error": "Unauthorized"
}
```
**500 Internal Server Error** - Внутренняя ошибка сервера
```json
{
"error": "Internal server error"
}
```
### Примечания
- **Пагинация:** При большом количестве executions рекомендуется использовать пагинацию с параметром `cursor`
- **includeData:** Установка `includeData=true` значительно увеличивает размер ответа, используйте только когда необходимы полные данные выполнения
- **Фильтрация:** Все параметры фильтрации можно комбинировать (например, `status=error&workflowId=123`)
- **Лимиты:** По умолчанию возвращается до 100 executions, максимум 250 за один запрос
- **Sorting:** Executions возвращаются отсортированными по времени начала (новые первыми)
---
## GET /api/v1/executions/{id}
### Описание
Получить детальную информацию о конкретном выполнении workflow по его ID.
### HTTP Метод
`GET`
### Endpoint
**Self-Hosted:**
```
<N8N_HOST>:<N8N_PORT>/<N8N_PATH>/api/v1/executions/{id}
```
**n8n Cloud:**
```
<instance>.app.n8n.cloud/api/v1/executions/{id}
```
### Параметры
#### Path Parameters (Параметры пути)
| Параметр | Тип | Обязательный | Описание |
|----------|-----|--------------|----------|
| `id` | integer | Required | ID выполнения для получения |
#### Query Parameters (Параметры запроса)
| Параметр | Тип | Обязательный | Описание |
|----------|-----|--------------|----------|
| `includeData` | boolean | Optional | Включить полные данные выполнения (по умолчанию: true) |
#### Request Headers (Заголовки запроса)
| Заголовок | Тип | Обязательный | Описание |
|-----------|-----|--------------|----------|
| `X-N8N-API-KEY` | string | Required | API ключ для аутентификации |
| `Accept` | string | Required | Должен быть `application/json` |
### Примеры
#### Пример запроса (curl)
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions/231' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
**Без полных данных:**
```bash
curl -X GET \
'https://n8n.example.com/api/v1/executions/231?includeData=false' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
#### Пример запроса (JavaScript/Node.js)
```javascript
const axios = require('axios');
// Функция для получения execution по ID
async function getExecution(executionId, includeData = true) {
try {
const response = await axios.get(`https://n8n.example.com/api/v1/executions/${executionId}`, {
params: {
includeData: includeData
},
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
const execution = response.data;
console.log(`Execution ${execution.id}:`);
console.log(` Workflow ID: ${execution.workflowId}`);
console.log(` Status: ${execution.finished ? 'Completed' : 'Running'}`);
console.log(` Started: ${execution.startedAt}`);
console.log(` Stopped: ${execution.stoppedAt}`);
console.log(` Mode: ${execution.mode}`);
return execution;
} catch (error) {
console.error('Ошибка получения execution:', error.response?.data || error.message);
throw error;
}
}
// Пример использования
const execution = await getExecution(231);
```
### Ответы
#### Success Response (200 OK)
**С полными данными (includeData=true):**
```json
{
"id": 231,
"finished": true,
"mode": "manual",
"retryOf": null,
"retrySuccessId": null,
"startedAt": "2025-12-25T10:30:00.000Z",
"stoppedAt": "2025-12-25T10:30:15.000Z",
"workflowId": 123,
"waitTill": null,
"customData": {
"userId": "user_123"
},
"data": {
"resultData": {
"runData": {
"Start": [
{
"name": "Start",
"type": "n8n-nodes-base.start",
"startTime": 1703501400000,
"endTime": 1703501400100,
"inputData": {
"main": [[]]
},
"outputData": {
"main": [[{ "json": {} }]]
}
}
],
"HTTP Request": [
{
"name": "HTTP Request",
"type": "n8n-nodes-base.httpRequest",
"startTime": 1703501400100,
"endTime": 1703501415000,
"inputData": {
"main": [[{ "json": {} }]]
},
"outputData": {
"main": [[{ "json": { "status": "success" } }]]
}
}
]
},
"lastNodeExecuted": "HTTP Request"
},
"workflowData": {
"name": "My Workflow",
"nodes": [
{
"name": "Start",
"type": "n8n-nodes-base.start",
"typeVersion": 1,
"position": [250, 300],
"parameters": {}
},
{
"name": "HTTP Request",
"type": "n8n-nodes-base.httpRequest",
"typeVersion": 4.1,
"position": [450, 300],
"parameters": {
"url": "https://api.example.com/data",
"method": "GET"
}
}
],
"connections": {
"Start": {
"main": [[{
"node": "HTTP Request",
"type": "main",
"index": 0
}]]
}
},
"active": true,
"settings": {}
}
}
}
```
**Без полных данных (includeData=false):**
```json
{
"id": 231,
"finished": true,
"mode": "manual",
"retryOf": null,
"retrySuccessId": null,
"startedAt": "2025-12-25T10:30:00.000Z",
"stoppedAt": "2025-12-25T10:30:15.000Z",
"workflowId": 123,
"waitTill": null,
"customData": {}
}
```
#### Error Responses
**404 Not Found** - Execution не найден
```json
{
"error": "Execution with ID 231 not found"
}
```
**401 Unauthorized** - Неверный или отсутствующий API ключ
```json
{
"error": "Unauthorized"
}
```
**500 Internal Server Error** - Внутренняя ошибка сервера
```json
{
"error": "Internal server error"
}
```
### Примечания
- **includeData:** По умолчанию включает полные данные выполнения. Для получения только метаданных используйте `includeData=false`
- **Размер данных:** Полные данные выполнения могут быть очень большими для сложных workflows
- **История:** Execution хранится согласно настройкам retention policy в n8n (см. EXECUTIONS_DATA_MAX_AGE, EXECUTIONS_DATA_PRUNE_MAX_COUNT)
---
## DELETE /api/v1/executions/{id}
### Описание
Удалить execution из истории выполнений. Эта операция необратима.
### HTTP Метод
`DELETE`
### Endpoint
**Self-Hosted:**
```
<N8N_HOST>:<N8N_PORT>/<N8N_PATH>/api/v1/executions/{id}
```
**n8n Cloud:**
```
<instance>.app.n8n.cloud/api/v1/executions/{id}
```
### Параметры
#### Path Parameters (Параметры пути)
| Параметр | Тип | Обязательный | Описание |
|----------|-----|--------------|----------|
| `id` | integer | Required | ID выполнения для удаления |
#### Request Headers (Заголовки запроса)
| Заголовок | Тип | Обязательный | Описание |
|-----------|-----|--------------|----------|
| `X-N8N-API-KEY` | string | Required | API ключ для аутентификации |
| `Accept` | string | Required | Должен быть `application/json` |
### Примеры
#### Пример запроса (curl)
```bash
curl -X DELETE \
'https://n8n.example.com/api/v1/executions/231' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Accept: application/json'
```
#### Пример запроса (JavaScript/Node.js)
```javascript
const axios = require('axios');
// Функция для удаления execution
async function deleteExecution(executionId) {
try {
const response = await axios.delete(`https://n8n.example.com/api/v1/executions/${executionId}`, {
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
console.log(`Execution ${executionId} успешно удален`);
return response.data;
} catch (error) {
console.error('Ошибка удаления execution:', error.response?.data || error.message);
throw error;
}
}
// Пример использования
await deleteExecution(231);
```
### Ответы
#### Success Response (204 No Content)
**Пустой ответ** - execution успешно удален
```
(пустое тело ответа)
```
#### Error Responses
**404 Not Found** - Execution не найден
```json
{
"error": "Execution with ID 231 not found"
}
```
**401 Unauthorized** - Неверный или отсутствующий API ключ
```json
{
"error": "Unauthorized"
}
```
**500 Internal Server Error** - Внутренняя ошибка сервера
```json
{
"error": "Internal server error"
}
```
### Примечания
- **Необратимость:** Удаление execution необратимо, восстановление невозможно
- **Cascading:** Удаление execution не влияет на workflow
- **Running executions:** Нельзя удалить execution, который в данный момент выполняется (статус `running` или `waiting`)
- **Bulk deletion:** Для массового удаления используйте настройки автоматической очистки (EXECUTIONS_DATA_PRUNE)
---
## POST /api/v1/executions/{id}/retry
### Описание
Повторить failed выполнение workflow. Доступно только для executions со статусом `error`. Создает новое execution, которое является retry оригинального.
### HTTP Метод
`POST`
### Endpoint
**Self-Hosted:**
```
<N8N_HOST>:<N8N_PORT>/<N8N_PATH>/api/v1/executions/{id}/retry
```
**n8n Cloud:**
```
<instance>.app.n8n.cloud/api/v1/executions/{id}/retry
```
### Параметры
#### Path Parameters (Параметры пути)
| Параметр | Тип | Обязательный | Описание |
|----------|-----|--------------|----------|
| `id` | integer | Required | ID failed execution для повтора |
#### Request Headers (Заголовки запроса)
| Заголовок | Тип | Обязательный | Описание |
|-----------|-----|--------------|----------|
| `X-N8N-API-KEY` | string | Required | API ключ для аутентификации |
| `Content-Type` | string | Required | Должен быть `application/json` |
| `Accept` | string | Required | Должен быть `application/json` |
### Примеры
#### Пример запроса (curl)
```bash
curl -X POST \
'https://n8n.example.com/api/v1/executions/231/retry' \
-H 'X-N8N-API-KEY: your_api_key_here' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
```
#### Пример запроса (JavaScript/Node.js)
```javascript
const axios = require('axios');
// Функция для повтора failed execution
async function retryExecution(executionId) {
try {
const response = await axios.post(
`https://n8n.example.com/api/v1/executions/${executionId}/retry`,
{},
{
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Content-Type': 'application/json',
'Accept': 'application/json'
}
}
);
const newExecution = response.data;
console.log(`Создано новое retry execution с ID: ${newExecution.id}`);
console.log(`Retry оригинального execution: ${newExecution.retryOf}`);
return newExecution;
} catch (error) {
console.error('Ошибка retry execution:', error.response?.data || error.message);
throw error;
}
}
// Пример использования
const retryExec = await retryExecution(231);
```
### Ответы
#### Success Response (201 Created)
```json
{
"id": 250,
"finished": false,
"mode": "retry",
"retryOf": 231,
"retrySuccessId": null,
"startedAt": "2025-12-25T11:00:00.000Z",
"stoppedAt": null,
"workflowId": 123,
"waitTill": null,
"customData": {},
"data": {
"resultData": {
"runData": {}
},
"workflowData": {
"name": "My Workflow",
"nodes": [...],
"connections": {...},
"active": true
}
}
}
```
**Поля ответа:**
| Поле | Тип | Описание |
|------|-----|----------|
| `id` | integer | ID нового retry execution |
| `mode` | string | Всегда `"retry"` для повторных выполнений |
| `retryOf` | integer | ID оригинального failed execution |
| `retrySuccessId` | integer\|null | ID успешного retry (если был) |
#### Error Responses
**400 Bad Request** - Execution не имеет статус `error`
```json
{
"error": "Execution 231 cannot be retried because it did not fail"
}
```
**404 Not Found** - Execution не найден
```json
{
"error": "Execution with ID 231 not found"
}
```
**401 Unauthorized** - Неверный или отсутствующий API ключ
```json
{
"error": "Unauthorized"
}
```
**500 Internal Server Error** - Внутренняя ошибка сервера
```json
{
"error": "Internal server error"
}
```
### Примечания
- **Только для failed:** Можно повторить только executions со статусом `error`
- **Новое execution:** Retry создает полностью новое execution с mode="retry"
- **retryOf:** Новое execution содержит ссылку на оригинальное в поле `retryOf`
- **retrySuccessId:** Если retry успешен, оригинальное execution получит ссылку в поле `retrySuccessId`
- **Workflow state:** Retry использует текущую версию workflow, не снапшот из оригинального execution
---
## Структура объекта Execution
### Полная структура Execution (TypeScript Interface)
```typescript
interface Execution {
// Основные поля
id: number; // Уникальный ID execution
workflowId: number; // ID workflow, который был выполнен
finished: boolean; // Завершено ли выполнение
mode: ExecutionMode; // Режим выполнения
startedAt: string; // ISO 8601 timestamp начала
stoppedAt: string; // ISO 8601 timestamp завершения
// Retry информация
retryOf?: number | null; // ID оригинального execution (для retry)
retrySuccessId?: number | null; // ID успешного retry (в оригинальном execution)
// Wait информация
waitTill?: string | null; // ISO 8601 timestamp до которого ждать
// Пользовательские данные
customData?: { // Произвольные пользовательские данные
[key: string]: any;
};
// Полные данные выполнения (если includeData=true)
data?: {
// Результаты выполнения
resultData: {
runData: {
[nodeName: string]: NodeExecutionData[];
};
lastNodeExecuted?: string;
error?: {
message: string;
stack?: string;
};
};
// Снапшот workflow на момент выполнения
workflowData: {
name: string;
nodes: Node[];
connections: Connections;
active: boolean;
settings?: object;
};
// Дополнительные метаданные выполнения
executionData?: {
contextData?: {
[key: string]: any;
};
nodeExecutionOrder?: string[];
waitingExecution?: object;
waitingExecutionSource?: object;
};
};
}
// Режим выполнения
type ExecutionMode =
| 'cli' // Выполнен через CLI
| 'error' // Выполнен через Error Trigger
| 'integrated' // Интеграционное выполнение
| 'internal' // Внутреннее выполнение
| 'manual' // Ручное выполнение через UI
| 'retry' // Повторное выполнение failed execution
| 'trigger' // Выполнен через trigger (webhook, schedule, etc.)
| 'webhook'; // Выполнен через webhook
// Данные выполнения одного node
interface NodeExecutionData {
name: string; // Имя node
type: string; // Тип node (например, 'n8n-nodes-base.httpRequest')
startTime: number; // Timestamp начала выполнения node (Unix milliseconds)
endTime?: number; // Timestamp завершения выполнения node
// Входные данные node
inputData: {
[key: string]: Array<{
[key: string]: any;
}>;
};
// Выходные данные node
outputData?: {
[key: string]: Array<{
[key: string]: any;
}>;
};
// Ошибка выполнения node
error?: {
message: string;
stack?: string;
name?: string;
description?: string;
};
}
// Node структура
interface Node {
name: string;
type: string;
typeVersion: number;
position: [number, number];
parameters: {
[key: string]: any;
};
credentials?: {
[credentialType: string]: {
id: string;
name: string;
};
};
}
// Connections структура
interface Connections {
[nodeName: string]: {
main?: Array<Array<{
node: string;
type: string;
index: number;
}>>;
};
}
```
### Примеры execution в различных состояниях
**Успешное execution:**
```json
{
"id": 100,
"workflowId": 50,
"finished": true,
"mode": "trigger",
"startedAt": "2025-12-25T10:00:00.000Z",
"stoppedAt": "2025-12-25T10:00:05.000Z",
"retryOf": null,
"retrySuccessId": null,
"waitTill": null
}
```
**Failed execution:**
```json
{
"id": 101,
"workflowId": 50,
"finished": true,
"mode": "manual",
"startedAt": "2025-12-25T10:05:00.000Z",
"stoppedAt": "2025-12-25T10:05:02.000Z",
"retryOf": null,
"retrySuccessId": 105,
"waitTill": null,
"data": {
"resultData": {
"runData": {...},
"lastNodeExecuted": "HTTP Request",
"error": {
"message": "Connection timeout",
"stack": "Error: Connection timeout\n at ..."
}
}
}
}
```
**Retry execution:**
```json
{
"id": 105,
"workflowId": 50,
"finished": true,
"mode": "retry",
"startedAt": "2025-12-25T10:10:00.000Z",
"stoppedAt": "2025-12-25T10:10:05.000Z",
"retryOf": 101,
"retrySuccessId": null,
"waitTill": null
}
```
**Waiting execution:**
```json
{
"id": 110,
"workflowId": 60,
"finished": false,
"mode": "webhook",
"startedAt": "2025-12-25T10:15:00.000Z",
"stoppedAt": null,
"retryOf": null,
"retrySuccessId": null,
"waitTill": "2025-12-25T11:15:00.000Z"
}
```
---
## Примеры использования
### Пример 1: Мониторинг failed executions
```javascript
const axios = require('axios');
async function monitorFailedExecutions() {
try {
// Получить все failed executions
const response = await axios.get('https://n8n.example.com/api/v1/executions', {
params: {
status: 'error',
limit: 50
},
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
const failedExecutions = response.data.data;
console.log(`Найдено ${failedExecutions.length} failed executions`);
// Группировка по workflow
const byWorkflow = failedExecutions.reduce((acc, exec) => {
if (!acc[exec.workflowId]) {
acc[exec.workflowId] = [];
}
acc[exec.workflowId].push(exec);
return acc;
}, {});
// Вывести статистику
for (const [workflowId, executions] of Object.entries(byWorkflow)) {
console.log(`\nWorkflow ${workflowId}: ${executions.length} failures`);
// Вывести последнюю ошибку
const latest = executions[0];
if (latest.data?.resultData?.error) {
console.log(` Последняя ошибка: ${latest.data.resultData.error.message}`);
}
}
return byWorkflow;
} catch (error) {
console.error('Ошибка мониторинга:', error.message);
throw error;
}
}
// Запуск мониторинга каждые 5 минут
setInterval(monitorFailedExecutions, 5 * 60 * 1000);
```
### Пример 2: Автоматический retry failed executions
```javascript
const axios = require('axios');
async function autoRetryFailedExecutions(workflowId) {
try {
// 1. Получить failed executions для конкретного workflow
const listResponse = await axios.get('https://n8n.example.com/api/v1/executions', {
params: {
status: 'error',
workflowId: workflowId,
limit: 10
},
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
const failedExecutions = listResponse.data.data;
console.log(`Найдено ${failedExecutions.length} failed executions для workflow ${workflowId}`);
// 2. Retry каждого failed execution
const retryResults = [];
for (const execution of failedExecutions) {
// Пропустить executions, которые уже были успешно повторены
if (execution.retrySuccessId) {
console.log(`Execution ${execution.id} уже имеет успешный retry ${execution.retrySuccessId}, пропускаем`);
continue;
}
try {
const retryResponse = await axios.post(
`https://n8n.example.com/api/v1/executions/${execution.id}/retry`,
{},
{
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Content-Type': 'application/json',
'Accept': 'application/json'
}
}
);
console.log(`✅ Создан retry execution ${retryResponse.data.id} для execution ${execution.id}`);
retryResults.push({
originalId: execution.id,
retryId: retryResponse.data.id,
status: 'created'
});
// Задержка между retry для избежания перегрузки
await new Promise(resolve => setTimeout(resolve, 1000));
} catch (retryError) {
console.error(`❌ Ошибка retry execution ${execution.id}:`, retryError.message);
retryResults.push({
originalId: execution.id,
retryId: null,
status: 'failed',
error: retryError.message
});
}
}
return retryResults;
} catch (error) {
console.error('Ошибка auto-retry:', error.message);
throw error;
}
}
// Пример использования
await autoRetryFailedExecutions(123);
```
### Пример 3: Очистка старых executions
```javascript
const axios = require('axios');
async function cleanupOldExecutions(daysOld = 30) {
try {
const cutoffDate = new Date();
cutoffDate.setDate(cutoffDate.getDate() - daysOld);
console.log(`Очистка executions старше ${daysOld} дней (до ${cutoffDate.toISOString()})`);
let deletedCount = 0;
let cursor = undefined;
let hasMore = true;
while (hasMore) {
// Получить executions
const response = await axios.get('https://n8n.example.com/api/v1/executions', {
params: {
limit: 100,
cursor: cursor,
includeData: false
},
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
const executions = response.data.data;
cursor = response.data.nextCursor;
hasMore = !!cursor;
// Фильтровать старые executions
const oldExecutions = executions.filter(exec => {
const execDate = new Date(exec.startedAt);
return execDate < cutoffDate;
});
console.log(`Найдено ${oldExecutions.length} старых executions в текущем batch`);
// Удалить каждое старое execution
for (const execution of oldExecutions) {
try {
await axios.delete(`https://n8n.example.com/api/v1/executions/${execution.id}`, {
headers: {
'X-N8N-API-KEY': 'your_api_key_here',
'Accept': 'application/json'
}
});
deletedCount++;
if (deletedCount % 10 === 0) {
console.log(`Удалено ${deletedCount} executions...`);
}
// Задержка для избежания перегрузки API
await new Promise(resolve => setTimeout(resolve, 100));
} catch (deleteError) {
console.error(`Ошибка удаления execution ${execution.id}:`, deleteError.message);
}
}
}
console.log(`✅ Всего удалено ${deletedCount} executions`);
return deletedCount;
} catch (error) {
console.error('Ошибка очистки executions:', error.message);
throw error;
}
}
// Пример использования
await cleanupOldExecutions(30); // Удалить executions старше 30 дней
```
---
## Дополнительные примечания
### Автоматическая очистка Executions
n8n поддерживает автоматическую очистку старых executions через environment variables:
**Настройки (Self-Hosted):**
```bash
# Включить автоматическую очистку
export EXECUTIONS_DATA_PRUNE=true
# Максимальный возраст executions в часах (168 = 7 дней)
export EXECUTIONS_DATA_MAX_AGE=168
# Максимальное количество executions для хранения
export EXECUTIONS_DATA_PRUNE_MAX_COUNT=50000
```
**Docker Compose:**
```yaml
n8n:
environment:
- EXECUTIONS_DATA_PRUNE=true
- EXECUTIONS_DATA_MAX_AGE=168
- EXECUTIONS_DATA_PRUNE_MAX_COUNT=50000
```
**Исключения из очистки:**
- Executions со статусом `new`, `running`, `waiting`
- Executions с аннотациями (annotations)
### Статусы Execution
| Статус | Описание |
|--------|----------|
| `success` | Execution успешно завершен без ошибок |
| `error` | Execution завершен с ошибкой |
| `waiting` | Execution ожидает (например, Wait node или Webhook response) |
| `new` | Execution только что создан, еще не начат |
| `running` | Execution в процессе выполнения |
### Режимы Execution (ExecutionMode)
| Режим | Описание |
|-------|----------|
| `manual` | Ручное выполнение через UI (кнопка "Execute Workflow") |
| `trigger` | Выполнение через trigger node (Schedule, Webhook, etc.) |
| `webhook` | Выполнение через webhook |
| `retry` | Повторное выполнение failed execution |
| `cli` | Выполнение через CLI |
| `error` | Выполнение через Error Trigger node |
| `integrated` | Интеграционное выполнение |
| `internal` | Внутреннее системное выполнение |
### Лучшие практики
1. **Пагинация:** Всегда используйте пагинацию при получении списков executions
2. **includeData:** Используйте `includeData=true` только когда необходимы полные данные
3. **Фильтрация:** Фильтруйте по workflowId и status для уменьшения объема данных
4. **Monitoring:** Регулярно мониторьте failed executions для выявления проблем
5. **Cleanup:** Настройте автоматическую очистку или используйте периодические задачи
6. **Retry:** Не retry executions автоматически без анализа причины ошибки
7. **Rate Limiting:** Используйте задержки между API запросами для избежания перегрузки
---
**Последнее обновление:** 2025-12-25
**Версия документации:** 1.0
**Подготовлено:** James (Dev Agent) с использованием Context7 MCP Server
