n8n-io/n8n · warning

admittance_rejected

admittance_rejected

Error message

admittance_rejected

What it means

Returned as HTTP 429 {error:'admittance_rejected', reason:...} when startExecution.start() throws AdmittanceRejectedError. The admittance gate (packages/@n8n/engine/src/admittance) rejects new executions under backpressure or capacity limits; the reason string explains why. This is a transient, server-side throttle — the request itself was well-formed and the graph valid.

Source

Thrown at packages/@n8n/engine/src/server/routes/workflow-executions.ts:71

export function createWorkflowExecutionsRouter(startExecution: StartExecutionService): RouterType {
	const router = Router();

	router.post('/', async (req, res) => {
		const parsed = StartExecutionBody.safeParse(req.body);
		if (!parsed.success) {
			res.status(400).json({
				error: 'invalid_request',
				details: parsed.error.flatten(),
			});
			return;
		}

		try {
			const result = await startExecution.start(parsed.data);
			res.status(201).json(result);
		} catch (error) {
			if (error instanceof AdmittanceRejectedError) {
				res.status(429).json({ error: 'admittance_rejected', reason: error.reason });
				return;
			}
			if (error instanceof GraphValidationError) {
				res.status(400).json({ error: 'invalid_graph', reason: error.message });
				return;
			}
			if (error instanceof UnimplementedError) {
				res.status(501).json({ error: 'unimplemented', reason: error.message });
				return;
			}
			throw error;
		}
	});

	return router;
}

View on GitHub (pinned to 5ac6606e81)

Solutions

1. Retry the request after a short backoff (honor 429 semantics); the reason field often indicates when to retry.
2. Reduce trigger fan-out or batch the submissions to stay under the concurrent-execution cap.
3. Raise the engine's admittance/capacity limits if the workload legitimately exceeds them.
4. Inspect the reason field to identify which resource is saturated (in-flight executions, queue depth).

Example fix

// before — fire and forget on a 429
const res = await fetch('/workflow-executions', { method: 'POST', body: JSON.stringify(payload) });
// after — retry with exponential backoff on admittance_rejected
async function startWithRetry(payload, attempts = 5) {
  for (let i = 0; i < attempts; i++) {
    const res = await fetch('/workflow-executions', { method: 'POST', body: JSON.stringify(payload) });
    if (res.status === 429) { await sleep(2 ** i * 200); continue; }
    return res;
  }
  throw new Error('admittance rejected after retries');
}

// No client-side validation prevents a server-side throttle; instead probe capacity if an endpoint exists.
// Otherwise, throttle locally to a rate you know the engine accepts.

async function startWithBackoff(payload, maxAttempts = 5) {
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch('/workflow-executions', { method: 'POST', body: JSON.stringify(payload) });
    if (res.status !== 429) return res;
    const body = await res.json(); // body.reason explains the limit
    await new Promise(r => setTimeout(r, 2 ** i * 200));
  }
  throw new Error('admittance_rejected after retries');
}

When it happens

Trigger: POST /workflow-executions while the engine is at its configured concurrent-execution or queue-depth limit. The admittance service rejects the execution before any step runs; reason typically names the limiting resource (e.g. max in-flight executions reached).

Common situations: Burst of workflow triggers exceeding capacity. A downstream dependency slowing the queue so executions pile up. Capacity misconfigured too low for the workload. Running load tests against a small engine instance.

Related errors

• Rate limit exceeded. Please wait a moment and try again.
• admittance_rejected
• invalid_request
• invalid_graph
• unimplemented

AI-assisted analysis of n8n-io/n8n@5ac6606e81 (2026-08-12). Data as JSON: /api/errors/ad9b596c3732fb65. Report an issue: GitHub.