feat(core): Add input/output token tracking to node graph telemetry (#27992)

Author: DawidMyslak

packages/@n8n/nodes-langchain/nodes/vendors/Anthropic/actions/text/message.operation.ts

@@ -5,7 +5,7 @@ import type {
 	INodeExecutionData,
 	INodeProperties,
 } from 'n8n-workflow';
-import { NodeOperationError, updateDisplayOptions } from 'n8n-workflow';
+import { accumulateTokenUsage, NodeOperationError, updateDisplayOptions } from 'n8n-workflow';
 import zodToJsonSchema from 'zod-to-json-schema';
 
 import { getConnectedTools } from '@utils/helpers';
@@ -343,6 +343,17 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		enableAnthropicBetas: { codeExecution: options.codeExecution },
 	})) as MessagesResponse;
 
+	const captureUsage = () => {
+		const usage = (response as unknown as Record<string, unknown>).usage as
+			| { input_tokens: number; output_tokens: number }
+			| undefined;
+		if (usage) {
+			accumulateTokenUsage(this, usage.input_tokens, usage.output_tokens);
+		}
+	};
+
+	captureUsage();
+
 	const maxToolsIterations = this.getNodeParameter('options.maxToolsIterations', i, 15) as number;
 	const abortSignal = this.getExecutionCancelSignal();
 	let currentIteration = 0;
@@ -382,6 +393,8 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 			body,
 			enableAnthropicBetas: { codeExecution: options.codeExecution },
 		})) as MessagesResponse;
+
+		captureUsage();
 	}
 
 	const mergedResponse = options.includeMergedResponse

packages/@n8n/nodes-langchain/nodes/vendors/GoogleGemini/actions/text/message.operation.ts

@@ -4,6 +4,7 @@ import {
 	type IExecuteFunctions,
 	type INodeExecutionData,
 	type INodeProperties,
+	accumulateTokenUsage,
 	jsonParse,
 	updateDisplayOptions,
 	validateNodeParameters,
@@ -510,6 +511,21 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		body,
 	})) as GenerateContentResponse;
 
+	const captureUsage = () => {
+		const usageMetadata = (response as unknown as Record<string, unknown>).usageMetadata as
+			| { promptTokenCount: number; candidatesTokenCount: number }
+			| undefined;
+		if (usageMetadata) {
+			accumulateTokenUsage(
+				this,
+				usageMetadata.promptTokenCount,
+				usageMetadata.candidatesTokenCount,
+			);
+		}
+	};
+
+	captureUsage();
+
 	const maxToolsIterations = this.getNodeParameter('options.maxToolsIterations', i, 15) as number;
 	const abortSignal = this.getExecutionCancelSignal();
 	let currentIteration = 1;
@@ -551,6 +567,7 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		response = (await apiRequest.call(this, 'POST', `/v1beta/${model}:generateContent`, {
 			body,
 		})) as GenerateContentResponse;
+		captureUsage();
 		toolCalls = getToolCalls(response);
 		currentIteration++;
 	}

packages/@n8n/nodes-langchain/nodes/vendors/Ollama/actions/text/message.operation.ts

@@ -1,6 +1,6 @@
 import type { Tool } from '@langchain/core/tools';
 import type { IExecuteFunctions, INodeExecutionData, INodeProperties } from 'n8n-workflow';
-import { updateDisplayOptions } from 'n8n-workflow';
+import { accumulateTokenUsage, updateDisplayOptions } from 'n8n-workflow';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
 import { getConnectedTools } from '@utils/helpers';
@@ -404,6 +404,10 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		body,
 	});
 
+	if (response.prompt_eval_count != null || response.eval_count != null) {
+		accumulateTokenUsage(this, response.prompt_eval_count ?? 0, response.eval_count ?? 0);
+	}
+
 	if (tools.length > 0 && response.message.tool_calls && response.message.tool_calls.length > 0) {
 		const toolCalls = response.message.tool_calls;
 
@@ -449,6 +453,10 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		response = await apiRequest.call(this, 'POST', '/api/chat', {
 			body: updatedBody,
 		});
+
+		if (response.prompt_eval_count != null || response.eval_count != null) {
+			accumulateTokenUsage(this, response.prompt_eval_count ?? 0, response.eval_count ?? 0);
+		}
 	}
 
 	if (simplify) {

packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/v1/actions/text/message.operation.ts

@@ -6,7 +6,7 @@ import type {
 	INodeExecutionData,
 	IDataObject,
 } from 'n8n-workflow';
-import { jsonParse, updateDisplayOptions } from 'n8n-workflow';
+import { accumulateTokenUsage, jsonParse, updateDisplayOptions } from 'n8n-workflow';
 
 import { getConnectedTools } from '@utils/helpers';
 
@@ -293,6 +293,10 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 
 	if (!response) return [];
 
+	if (response.usage) {
+		accumulateTokenUsage(this, response.usage.prompt_tokens, response.usage.completion_tokens);
+	}
+
 	let currentIteration = 1;
 	let toolCalls = response?.choices[0]?.message?.tool_calls;
 
@@ -334,6 +338,10 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 			body,
 		})) as ChatCompletion;
 
+		if (response.usage) {
+			accumulateTokenUsage(this, response.usage.prompt_tokens, response.usage.completion_tokens);
+		}
+
 		toolCalls = response.choices[0].message.tool_calls;
 		currentIteration += 1;
 	}

packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/v2/actions/text/response.operation.ts

@@ -7,7 +7,12 @@ import type {
 	INodeExecutionData,
 	INodeProperties,
 } from 'n8n-workflow';
-import { jsonParse, NodeOperationError, updateDisplayOptions } from 'n8n-workflow';
+import {
+	accumulateTokenUsage,
+	jsonParse,
+	NodeOperationError,
+	updateDisplayOptions,
+} from 'n8n-workflow';
 import { MODELS_NOT_SUPPORT_FUNCTION_CALLS } from '../../../helpers/constants';
 import type { ChatResponse } from '../../../helpers/interfaces';
 import { formatToOpenAIResponsesTool } from '../../../helpers/utils';
@@ -630,6 +635,10 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 
 	if (!response) return [];
 
+	if (response.usage) {
+		accumulateTokenUsage(this, response.usage.input_tokens, response.usage.output_tokens);
+	}
+
 	// reasoning models such as gpt5 include reasoning items that must be included in the request
 	const isToolRelatedCall: (item: { type: string }) => boolean = (item) =>
 		item.type === 'function_call' || item.type === 'reasoning';
@@ -681,6 +690,11 @@ export async function execute(this: IExecuteFunctions, i: number): Promise<INode
 		response = (await apiRequest.call(this, 'POST', '/responses', {
 			body,
 		})) as ChatResponse;
+
+		if (response.usage) {
+			accumulateTokenUsage(this, response.usage.input_tokens, response.usage.output_tokens);
+		}
+
 		toolCalls = response.output.filter(isToolRelatedCall);
 
 		currentIteration++;

packages/workflow/src/interfaces.ts

@@ -2780,6 +2780,15 @@ export interface ITaskMetadata {
 	 */
 	resumeUrl?: string;
 
+	/**
+	 * AI model token usage captured from vendor node API responses before the simplify step
+	 * strips it. Used by telemetry to populate ai_input_tokens / ai_output_tokens in node_graph_string.
+	 */
+	tokenUsage?: {
+		inputTokens: number;
+		outputTokens: number;
+	};
+
 	/**
 	 * Key-value pairs that can be set for tracing - they will be attached to the OTEL node span
 	 * */
@@ -3258,6 +3267,8 @@ export interface INodeGraphItem {
 	used_guardrails?: string[]; // only for @n8n/n8n-nodes-langchain.guardrails
 	mcp_client_auth_method?: string; // for @n8n/n8n-nodes-langchain.mcpClientTool and @n8n/n8n-nodes-langchain.mcpClient
 	ai_model?: string; // AI model for model nodes and standalone AI nodes
+	ai_input_tokens?: number; // AI input (prompt) tokens for model nodes
+	ai_output_tokens?: number; // AI output (completion) tokens for model nodes
 }
 
 export interface INodeNameIndex {

packages/workflow/src/metadata-utils.ts

@@ -1,4 +1,4 @@
-import type { ITaskMetadata } from '.';
+import type { IExecuteFunctions, ITaskMetadata } from '.';
 import { hasKey } from './utils';
 
 function responseHasSubworkflowData(
@@ -23,6 +23,20 @@ function parseErrorResponseWorkflowMetadata(response: unknown): ISubWorkflowMeta
 	};
 }
 
+export function accumulateTokenUsage(
+	context: IExecuteFunctions,
+	inputTokens: number,
+	outputTokens: number,
+): void {
+	const prev = context.getExecuteData()?.metadata?.tokenUsage;
+	context.setMetadata({
+		tokenUsage: {
+			inputTokens: (prev?.inputTokens ?? 0) + inputTokens,
+			outputTokens: (prev?.outputTokens ?? 0) + outputTokens,
+		},
+	});
+}
+
 export function parseErrorMetadata(error: unknown): ISubWorkflowMetadata | undefined {
 	if (hasKey(error, 'errorResponse')) {
 		return parseErrorResponseWorkflowMetadata(error.errorResponse);

packages/workflow/src/telemetry-helpers.ts

@@ -62,6 +62,17 @@ export function isNumber(value: unknown): value is number {
 	return typeof value === 'number';
 }
 
+function isTokenUsage(value: unknown): value is { promptTokens: number; completionTokens: number } {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		'promptTokens' in value &&
+		typeof value.promptTokens === 'number' &&
+		'completionTokens' in value &&
+		typeof value.completionTokens === 'number'
+	);
+}
+
 function resolveParameterValue(value: unknown): string | undefined {
 	if (typeof value === 'string') {
 		return value;
@@ -74,6 +85,32 @@ function resolveParameterValue(value: unknown): string | undefined {
 	return undefined;
 }
 
+function extractNodeTokenUsage(
+	nodeRunData: ITaskData[],
+): { input: number; output: number } | undefined {
+	let input = 0;
+	let output = 0;
+	for (const task of nodeRunData) {
+		const lmOutputs = task.data?.[NodeConnectionTypes.AiLanguageModel];
+		if (lmOutputs) {
+			// LM sub-nodes (connected to Agent/Chain) — token data from N8nLlmTracing
+			for (const branch of lmOutputs) {
+				for (const item of branch ?? []) {
+					const usage = item?.json?.tokenUsage ?? item?.json?.tokenUsageEstimate;
+					if (!isTokenUsage(usage)) continue;
+					input += usage.promptTokens;
+					output += usage.completionTokens;
+				}
+			}
+		} else if (task.metadata?.tokenUsage) {
+			// Standalone vendor nodes — token data captured via setMetadata before simplify
+			input += task.metadata.tokenUsage.inputTokens ?? 0;
+			output += task.metadata.tokenUsage.outputTokens ?? 0;
+		}
+	}
+	return input > 0 || output > 0 ? { input, output } : undefined;
+}
+
 const countPlaceholders = (text: string) => {
 	const placeholder = /(\{[a-zA-Z0-9_]+\})/g;
 	let returnData = 0;
@@ -613,6 +650,14 @@ export function generateNodesGraph(
 			}
 		}
 
+		if (nodeItem.ai_model && runData?.[node.name]) {
+			const tokenUsage = extractNodeTokenUsage(runData[node.name]);
+			if (tokenUsage) {
+				nodeItem.ai_input_tokens = tokenUsage.input;
+				nodeItem.ai_output_tokens = tokenUsage.output;
+			}
+		}
+
 		if (options?.isCloudDeployment === true) {
 			if (node.type === OPENAI_LANGCHAIN_NODE_TYPE) {
 				nodeItem.prompts =

packages/workflow/test/metadata-utils.test.ts

@@ -1,6 +1,52 @@
-import { parseErrorMetadata } from '../src/metadata-utils';
+import type { IExecuteData, IExecuteFunctions, ITaskMetadata } from '../src/interfaces';
+import { accumulateTokenUsage, parseErrorMetadata } from '../src/metadata-utils';
+
+function createMockContext(metadata?: ITaskMetadata): IExecuteFunctions {
+	const executeData: IExecuteData = {
+		data: {},
+		node: {} as IExecuteData['node'],
+		source: null,
+		metadata,
+	};
+	return {
+		getExecuteData: () => executeData,
+		setMetadata(newMetadata: ITaskMetadata) {
+			executeData.metadata = { ...executeData.metadata, ...newMetadata };
+		},
+	} as unknown as IExecuteFunctions;
+}
 
 describe('MetadataUtils', () => {
+	describe('accumulateTokenUsage', () => {
+		it('should set token usage when no previous metadata exists', () => {
+			const context = createMockContext();
+			accumulateTokenUsage(context, 100, 50);
+			expect(context.getExecuteData().metadata?.tokenUsage).toEqual({
+				inputTokens: 100,
+				outputTokens: 50,
+			});
+		});
+
+		it('should accumulate tokens across multiple calls', () => {
+			const context = createMockContext();
+			accumulateTokenUsage(context, 100, 50);
+			accumulateTokenUsage(context, 200, 80);
+			accumulateTokenUsage(context, 50, 20);
+			expect(context.getExecuteData().metadata?.tokenUsage).toEqual({
+				inputTokens: 350,
+				outputTokens: 150,
+			});
+		});
+
+		it('should preserve existing metadata fields', () => {
+			const context = createMockContext({ subExecutionsCount: 3 });
+			accumulateTokenUsage(context, 100, 50);
+			const metadata = context.getExecuteData().metadata;
+			expect(metadata?.subExecutionsCount).toBe(3);
+			expect(metadata?.tokenUsage).toEqual({ inputTokens: 100, outputTokens: 50 });
+		});
+	});
+
 	describe('parseMetadataFromError', () => {
 		const expectedMetadata = {
 			subExecution: {