How to Handle n8n Timeout Errors on Long Completions from Mistral

n8n has three timeout layers that can cause failures: (1) the HTTP Request node's own timeout, (2) the workflow execution timeout, and (3) the server-level execution timeout set via environment variables. Check the error message to identify the source. 'ETIMEDOUT' or 'socket hang up' means the HTTP Request node timed out. 'Workflow execution timed out' means the workflow-level limit was hit. 'The execution has timed out' with no node name means the server-level timeout fired. Each requires a different fix.

Open the HTTP Request node that calls the Mistral API. Go to Options (at the bottom of the node settings) and find the Timeout field. Set it to 600000 (600 seconds / 10 minutes). This is the maximum time the node will wait for a response from Mistral before throwing an ETIMEDOUT error. For most Mistral completions, 120-180 seconds is sufficient, but setting a generous timeout prevents failures on unusually complex prompts.

1// HTTP Request node configuration
2// Method: POST
3// URL: https://api.mistral.ai/v1/chat/completions
4// Authentication: Header Auth
5//   Name: Authorization
6//   Value: Bearer {{ $credentials.mistralApi.apiKey }}
7// Options:
8//   Timeout: 600000
9//   Retry On Fail: true
10//   Max Tries: 2
11//   Wait Between Tries: 5000

Each workflow in n8n has its own execution timeout. Open Workflow Settings (gear icon in the top-right of the workflow editor) and set the Timeout Workflow After field to 900 seconds (15 minutes). This must be higher than your HTTP Request timeout to prevent the workflow from being killed while the node is still waiting for Mistral. On n8n Cloud, the maximum workflow timeout is 900 seconds on Pro plans.

If you are running n8n self-hosted, there is a server-level execution timeout controlled by environment variables. Set EXECUTIONS_TIMEOUT to -1 (unlimited) or a high value like 3600 (1 hour). Also set EXECUTIONS_TIMEOUT_MAX to the same value. These environment variables cap the maximum time any workflow can run, regardless of workflow-level settings. If these are set lower than your workflow timeout, they take precedence and will kill the execution.

1# Environment variables for self-hosted n8n
2# Add to your .env file or Docker Compose environment
3
4EXECUTIONS_TIMEOUT=3600
5EXECUTIONS_TIMEOUT_MAX=3600
6
7# For Docker Compose:
8# environment:
9#   - EXECUTIONS_TIMEOUT=3600
10#   - EXECUTIONS_TIMEOUT_MAX=3600

Instead of waiting for Mistral to generate the entire response, use streaming to receive tokens incrementally. Set stream: true in the Mistral API request body. The HTTP Request node will receive the response as a stream of Server-Sent Events (SSE). This keeps the connection alive and avoids timeout because data flows continuously. After receiving the streamed response, use a Code node to concatenate the chunks into the final response text.

1// HTTP Request node body (JSON) — enable streaming
2{
3  "model": "mistral-large-latest",
4  "messages": [
5    {
6      "role": "system",
7      "content": "You are a helpful coding assistant."
8    },
9    {
10      "role": "user",
11      "content": "{{ $json.prompt }}"
12    }
13  ],
14  "max_tokens": 4096,
15  "temperature": 0.2,
16  "stream": true
17}
18
19// Then in a Code node after the HTTP Request:
20// Parse SSE stream into final text
21const raw = $input.first().json.data || $input.first().binary?.data;
22const text = String(raw);
23
24const chunks = text
25  .split('\n')
26  .filter(line => line.startsWith('data: ') && !line.includes('[DONE]'))
27  .map(line => {
28    try {
29      const parsed = JSON.parse(line.replace('data: ', ''));
30      return parsed.choices?.[0]?.delta?.content || '';
31    } catch { return ''; }
32  });
33
34const fullResponse = chunks.join('');
35return [{ json: { response: fullResponse } }];

If your prompts consistently trigger long completions (over 2 minutes), consider splitting the task into smaller sub-tasks. Use the SplitInBatches node to break a complex prompt into sequential simpler prompts. For example, instead of asking Mistral to generate an entire application in one request, ask it to generate one component at a time. Each sub-request completes faster and stays safely within timeout limits. Combine the results in a final Code node.