How to Fix Webhook Replies Arriving Too Late for LLM Processing in n8n

When the Webhook node's Response Mode is set to 'Last Node' or 'Using Respond to Webhook Node' (placed after the LLM node), n8n holds the HTTP connection open until the LLM finishes. If the LLM takes 15 seconds but the caller's HTTP client timeout is 10 seconds, the caller receives a timeout error. Meanwhile, the n8n workflow continues running, processes the LLM call successfully, and tries to send the response, but the connection is already closed. The caller gets no result and may retry, causing the LLM to process the same request again. To fix this, you need to split the workflow into two phases: immediate acknowledgment and deferred delivery.

Set the Webhook node's Response Mode to 'Using Respond to Webhook Node'. Then add a Code node immediately after the Webhook that generates a processing ID and extracts the callback URL from the request. Connect this Code node to a Respond to Webhook node. Configure the Respond to Webhook node to return HTTP status 202 (Accepted) with a JSON body containing the processing ID and an estimated completion time. Place this Respond to Webhook node BEFORE the LLM node in the workflow. After the Respond to Webhook sends the immediate reply, the workflow continues to the LLM node without holding the HTTP connection.

1// Code node: Prepare Async Response
2const webhook = $input.first().json;
3const body = webhook.body || webhook;
4
5const processingId = $execution.id;
6
7return [{
8  json: {
9    // Fields for immediate webhook response
10    processingId: processingId,
11    status: 'accepted',
12    message: 'Your request is being processed.',
13    estimatedSeconds: 15,
14    
15    // Fields for LLM processing (passed downstream)
16    chatInput: body.message || body.text || '',
17    sessionId: body.sessionId || processingId,
18    callbackUrl: body.callbackUrl || body.callback_url || null
19  }
20}];
21
22// Respond to Webhook node settings:
23// Response Code: 202
24// Response Data: First Entry JSON
25// (This returns the processingId, status, message, estimatedSeconds fields)

After the Respond to Webhook node, connect your LLM node (AI Agent, Basic LLM Chain, etc.) as usual. The webhook connection is already closed, so the LLM can take as long as needed without any timeout pressure. Configure the LLM node with the chatInput and sessionId from the Code node's output. Add error handling (On Error: Continue) so failures are captured instead of crashing the workflow. After the LLM node, add another Code node that packages the result with the processing ID for delivery.

1// Code node after LLM: Package Result for Delivery
2const llmOutput = $input.first().json;
3const processingId = $('Prepare Async Response').first().json.processingId;
4const callbackUrl = $('Prepare Async Response').first().json.callbackUrl;
5
6return [{
7  json: {
8    processingId: processingId,
9    callbackUrl: callbackUrl,
10    result: {
11      status: 'completed',
12      processingId: processingId,
13      response: llmOutput.output || llmOutput.text || '',
14      completedAt: new Date().toISOString()
15    }
16  }
17}];

If the caller provided a callback URL in the original request, use an HTTP Request node to POST the result to that URL. Add an IF node after the LLM result packaging that checks whether a callback URL exists. If it does, route to the HTTP Request node. Configure the HTTP Request node to POST to {{ $json.callbackUrl }} with the result object as the JSON body. Add error handling on the HTTP Request node in case the callback URL is unreachable. If the callback fails, store the result in a database or queue for later retrieval. This is the most efficient delivery method because results are pushed immediately after processing.

1// HTTP Request node settings:
2// Method: POST
3// URL: {{ $json.callbackUrl }}
4// Body Content Type: JSON
5// Body: {{ $json.result }}
6// Options > Timeout: 10000 (10 seconds)
7// On Error: Continue

Not all callers can receive callbacks. Create a second webhook in a separate workflow that acts as a status-checking endpoint. This endpoint accepts GET requests with the processing ID and returns the result if it is ready, or a 'processing' status if the LLM is still running. Store results in a database (Postgres, Redis, or n8n's static data) after the LLM completes. The polling workflow queries the database by processing ID and returns the result. The caller polls this endpoint every few seconds until the result is available. Include a TTL so results are cleaned up after retrieval.

1// Main workflow: Store result after LLM completes
2// Code node: Store Result
3const staticData = $getWorkflowStaticData('global');
4const result = $input.first().json;
5
6if (!staticData.results) staticData.results = {};
7
8staticData.results[result.processingId] = {
9  ...result.result,
10  storedAt: Date.now()
11};
12
13// Clean up results older than 5 minutes
14const FIVE_MINUTES = 5 * 60 * 1000;
15for (const id in staticData.results) {
16  if (Date.now() - staticData.results[id].storedAt > FIVE_MINUTES) {
17    delete staticData.results[id];
18  }
19}
20
21return [$input.first()];
22
23// ---
24// Polling workflow (separate):
25// Webhook (GET /result/:id) → Code node:
26const staticData = $getWorkflowStaticData('global');
27const processingId = $json.params?.id || $json.query?.id || '';
28
29const result = staticData.results?.[processingId];
30
31if (result) {
32  delete staticData.results[processingId];
33  return [{ json: { status: 'completed', ...result } }];
34} else {
35  return [{ json: { status: 'processing', processingId } }];
36}

When callers time out, they often retry the same request. Without deduplication, the LLM processes the same prompt multiple times, wasting tokens and money. Add an idempotency check at the start of the workflow using a request ID provided by the caller or a hash of the request body. Before starting LLM processing, check if a result already exists for this request ID. If it does, return the cached result immediately. If it does not, proceed with processing. Use n8n's static data or a database to store the mapping from request ID to processing status.

1// Code node: Deduplication Check (place before Respond to Webhook)
2const staticData = $getWorkflowStaticData('global');
3const body = $input.first().json.body || $input.first().json;
4
5// Use client-provided request ID or hash the message
6const requestId = body.requestId || body.idempotencyKey || '';
7let isDuplicate = false;
8let existingResult = null;
9
10if (requestId && staticData.requests?.[requestId]) {
11  isDuplicate = true;
12  existingResult = staticData.requests[requestId];
13} else if (requestId) {
14  if (!staticData.requests) staticData.requests = {};
15  staticData.requests[requestId] = {
16    processingId: $execution.id,
17    status: 'processing',
18    startedAt: Date.now()
19  };
20}
21
22return [{
23  json: {
24    ...body,
25    processingId: isDuplicate ? existingResult.processingId : $execution.id,
26    isDuplicate: isDuplicate,
27    existingResult: existingResult
28  }
29}];
30
31// Follow with IF node: {{ $json.isDuplicate }}
32// True → Return cached result
33// False → Continue to LLM processing