Extracting Provider Metrics
To send accurate telemetry to the OTM API, you need to grab real-time metrics (like prompt tokens, completion tokens, and timing) directly from your LLM provider’s response.
Every SDK hides these metrics in slightly different places. This guide shows you exactly where to find them so you don’t have to spend hours digging through documentation or console logging response objects.
Pro Tip: Always capture the startTime right before you make the API call
and firstTokenTime when you receive the first chunk if you’re streaming.
This ensures your TTFT (Time To First Token) metrics are spot on.
OpenAI
OpenAI makes it relatively easy to get token usage, provided you aren’t streaming. For streaming, you’ll need to look at the final chunk.
const response = await openai.chat.completions.create({
model: "gpt-4o",
messages: [{ role: "user", content: "Hello!" }],
});
// Here is the gold mine:
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(`Used ${prompt_tokens} input and ${completion_tokens} output tokens.`);Anthropic
Anthropic calls their usage fields input_tokens and output_tokens. If you use prompt caching, they also provide cache_creation_input_tokens and cache_read_input_tokens.
const message = await anthropic.messages.create({
model: "claude-3-5-sonnet-20240620",
max_tokens: 1024,
messages: [{ role: "user", content: "Hi Claude!" }],
});
// Standard usage extraction
const { input_tokens, output_tokens } = message.usage;
// If you use caching, keep an eye on these too:
const cacheRead = message.usage.cache_read_input_tokens || 0;Google Gemini
Google wraps their usage in a usageMetadata object (CamelCase in JS/Go, snake_case in Python).
const result = await model.generateContent("Explain telemetry.");
const response = await result.response;
// Gemini calls them promptTokenCount and candidatesTokenCount
const { promptTokenCount, candidatesTokenCount } = response.usageMetadata;
console.log(`Prompt: ${promptTokenCount}, Output: ${candidatesTokenCount}`);Alibaba Cloud (DashScope)
Alibaba Cloud’s DashScope API returns token usage inside a usage object. You’ll typically find the number of input and output tokens in input_tokens and output_tokens.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
});
const response = await client.chat.completions.create({
model: "qwen-plus",
messages: [
{ role: "user", content: "Explain telemetry." },
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Cohere
Cohere exposes token usage through the meta.billed_units object, which contains separate counts for input and output tokens.
import { CohereClient } from "cohere-ai";
const cohere = new CohereClient({
token: process.env.COHERE_API_KEY,
});
const response = await cohere.chat({
model: "command-r-plus",
message: "Explain telemetry.",
});
// Token usage
const inputTokens = response.meta.billedUnits.inputTokens;
const outputTokens = response.meta.billedUnits.outputTokens;
console.log(
`Prompt: ${inputTokens}, Output: ${outputTokens}`
);Meta (Llama)
Meta’s Llama models are commonly accessed through OpenAI-compatible APIs (such as Together AI, Fireworks AI, Groq, or other compatible providers). These APIs expose token usage through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.META_API_KEY,
baseURL: process.env.META_BASE_URL,
});
const response = await client.chat.completions.create({
model: "meta-llama/llama-4-maverick",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Mistral
Mistral’s official SDK returns token usage through the usage object containing prompt, completion, and total token counts.
import { Mistral } from "@mistralai/mistralai";
const client = new Mistral({
apiKey: process.env.MISTRAL_API_KEY,
});
const response = await client.chat.complete({
model: "mistral-large-latest",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { promptTokens, completionTokens, totalTokens } = response.usage;
console.log(
`Prompt: ${promptTokens}, Output: ${completionTokens}, Total: ${totalTokens}`,
);xAI (Grok)
xAI provides an OpenAI-compatible API. Token usage is available through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.XAI_API_KEY,
baseURL: "https://api.x.ai/v1",
});
const response = await client.chat.completions.create({
model: "grok-4",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Sarvam AI
Sarvam AI exposes an OpenAI-compatible Chat Completions API. Token usage is returned in the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.SARVAM_API_KEY,
baseURL: "https://api.sarvam.ai/v1",
});
const response = await client.chat.completions.create({
model: "sarvam-105b",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Moonshot AI (Kimi)
Moonshot AI exposes an OpenAI-compatible Chat Completions API. Token usage is returned in the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.MOONSHOT_API_KEY,
baseURL: "https://api.moonshot.ai/v1",
});
const response = await client.chat.completions.create({
model: "kimi-k2",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Z.ai
Z.ai exposes an OpenAI-compatible Chat Completions API. Token usage is available through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.ZAI_API_KEY,
baseURL: "https://api.z.ai/api/paas/v4",
});
const response = await client.chat.completions.create({
model: "glm-4.5",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);DeepSeek
DeepSeek provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.DEEPSEEK_API_KEY,
baseURL: "https://api.deepseek.com",
});
const response = await client.chat.completions.create({
model: "deepseek-chat",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Tencent Cloud (Hunyuan)
Tencent Cloud’s Hunyuan models provide an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object, with prompt_tokens, completion_tokens, and total_tokens.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.TENCENT_API_KEY,
baseURL: "https://api.hunyuan.cloud.tencent.com/v1",
});
const response = await client.chat.completions.create({
model: "hunyuan-turbos-latest",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Upstage (Solar)
Upstage provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.UPSTAGE_API_KEY,
baseURL: "https://api.upstage.ai/v1",
});
const response = await client.chat.completions.create({
model: "solar-pro4",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);NVIDIA (Nemotron)
NVIDIA provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.NVIDIA_API_KEY,
baseURL: "https://integrate.api.nvidia.com/v1",
});
const response = await client.chat.completions.create({
model: "nvidia/nemotron-3-super-120b-a12b",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);StepFun
StepFun provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.STEPFUN_API_KEY,
baseURL: "https://api.stepfun.com/v1",
});
const response = await client.chat.completions.create({
model: "step-3.7-flash",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);inclusionAI (Ling)
inclusionAI provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.INCLUSIONAI_API_KEY,
baseURL: "https://api.inclusion.ai/v1",
});
const response = await client.chat.completions.create({
model: "ling-3.0-flash",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);IBM (Granite)
IBM Granite models can be accessed through OpenAI-compatible APIs. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.IBM_API_KEY,
baseURL: process.env.IBM_BASE_URL,
});
const response = await client.chat.completions.create({
model: "granite-4-2-8b",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);ByteDance Seed
ByteDance Seed provides an OpenAI-compatible Chat Completions API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.BYTEDANCE_SEED_API_KEY,
baseURL: process.env.BYTEDANCE_SEED_BASE_URL,
});
const response = await client.chat.completions.create({
model: "seed-2-1-turbo",
messages: [
{
role: "user",
content: "Explain telemetry.",
},
],
});
// Usage information
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Amazon Bedrock
Amazon Bedrock’s Converse API returns token counts in the response’s usage object. The field names use camelCase: inputTokens, outputTokens, and totalTokens. For streaming responses, read usage from the stream’s final metadata event. Amazon Bedrock documentation
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
const bedrock = new BedrockRuntimeClient({
region: process.env.AWS_REGION,
});
const response = await bedrock.send(
new ConverseCommand({
modelId: "amazon.nova-lite-v1:0",
messages: [
{
role: "user",
content: [{ text: "Explain telemetry." }],
},
],
}),
);
// Extract token usage
const { inputTokens, outputTokens, totalTokens } = response.usage;
console.log(
`Input: ${inputTokens}, Output: ${outputTokens}, Total: ${totalTokens}`,
);Microsoft Azure OpenAI
Azure OpenAI returns token usage in the usage object, using the same field names as the OpenAI Chat Completions API: prompt_tokens, completion_tokens, and total_tokens. You can map prompt_tokens to input tokens and completion_tokens to output tokens for telemetry. Azure OpenAI documentation
import { AzureOpenAI } from "openai";
const client = new AzureOpenAI({
endpoint: process.env.AZURE_OPENAI_ENDPOINT,
apiKey: process.env.AZURE_OPENAI_API_KEY,
apiVersion: process.env.AZURE_OPENAI_API_VERSION,
});
const response = await client.chat.completions.create({
model: process.env.AZURE_OPENAI_DEPLOYMENT,
messages: [{ role: "user", content: "Explain telemetry." }],
});
// Extract token usage
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Input: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`,
);Inception AI
Inception AI models can be accessed through an OpenAI-compatible API. Token usage is available through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.INCEPTION_AI_API_KEY,
baseURL: process.env.INCEPTION_AI_BASE_URL,
});
const response = await client.chat.completions.create({
model: "mercury-2",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Liquid AI
Liquid AI models can be accessed through an OpenAI-compatible API. Token usage can be extracted from the response’s usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.LIQUID_AI_API_KEY,
baseURL: process.env.LIQUID_AI_BASE_URL,
});
const response = await client.chat.completions.create({
model: "lfm-2.5-2.6b:free",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Nex AGI
Nex AGI models can be accessed through an OpenAI-compatible API. Token usage is available through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.NEX_AGI_API_KEY,
baseURL: process.env.NEX_AGI_BASE_URL,
});
const response = await client.chat.completions.create({
model: "nex-n2.5-mini",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Reflection
Reflection models can be accessed through an OpenAI-compatible API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.REFLECTION_API_KEY,
baseURL: process.env.REFLECTION_BASE_URL,
});
const response = await client.chat.completions.create({
model: "beam-1.0-501b-a23b",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);thinkingmachines
thinkingmachines models can be accessed through an OpenAI-compatible API. Token usage is available through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.THINKINGMACHINES_API_KEY,
baseURL: process.env.THINKINGMACHINES_BASE_URL,
});
const response = await client.chat.completions.create({
model: "inkling-small",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Inference.net
Inference.net models can be accessed through an OpenAI-compatible API. Token usage is returned through the standard usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.INFERENCE_NET_API_KEY,
baseURL: process.env.INFERENCE_NET_BASE_URL,
});
const response = await client.chat.completions.create({
model: "schematron-v2-turbo",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } =
response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);AionLabs
AionLabs exposes token usage through an OpenAI-compatible chat completions response. Read the usage object returned with the completion.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.AIONLABS_API_KEY,
baseURL: process.env.AIONLABS_BASE_URL,
});
const response = await client.chat.completions.create({
model: "aion-3.5",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Moondream
Moondream’s OpenAI-compatible chat completions response includes token counts in usage.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.MOONDREAM_API_KEY,
baseURL: process.env.MOONDREAM_BASE_URL,
});
const response = await client.chat.completions.create({
model: "moondream3.1",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Elorian
When using Elorian through OpenRouter’s OpenAI-compatible API, read token usage from the returned usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: "https://openrouter.ai/api/v1",
});
const response = await client.chat.completions.create({
model: "elorian/glimpse",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);XingChen
XingChen’s OpenAI-compatible API returns token counts in the completion’s usage object. Set the base URL and model ID to the values provided for your XingChen account.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.XINGCHEN_API_KEY,
baseURL: process.env.XINGCHEN_BASE_URL,
});
const response = await client.chat.completions.create({
model: "Xing4.0-29B-A4B",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Recursive
When calling Recursive through OpenRouter, token usage is available in the standard OpenAI-compatible usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: "https://openrouter.ai/api/v1",
});
const response = await client.chat.completions.create({
model: "recursive/flint-v1.0:free",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Perplexity
When calling Perplexity through OpenRouter, token usage is available in the standard OpenAI-compatible usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: "https://openrouter.ai/api/v1",
});
const response = await client.chat.completions.create({
model: "perplexity/sonar",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Particle AI
When calling Particle AI through OpenRouter, token usage is available in the standard OpenAI-compatible usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: "https://openrouter.ai/api/v1",
});
const response = await client.chat.completions.create({
model: "particle-ai/particle-1",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Sakana AI
When calling Sakana AI through OpenRouter, token usage is available in the standard OpenAI-compatible usage object.
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: "https://openrouter.ai/api/v1",
});
const response = await client.chat.completions.create({
model: "sakana/fugu-ultra-v2",
messages: [{ role: "user", content: "Explain telemetry." }],
});
const { prompt_tokens, completion_tokens, total_tokens } = response.usage;
console.log(
`Prompt: ${prompt_tokens}, Output: ${completion_tokens}, Total: ${total_tokens}`
);Next Steps
Now that you’ve got the raw numbers, you’re ready to format them for the Telemetry Usage API. Just map these values to the tokens.input and tokens.output fields in your payload, and you’re good to go!