ModulesAI ModuleAPIsExtracting Metrics

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!