How to Calculate Token Usage Cost Accurately in Python & TypeScript

import tiktoken
from openai import OpenAI
from dataclasses import dataclass

PRICING: dict[str, tuple[float, float]] = {
    "gpt-4o": (2.50, 10.00),
    "gpt-4o-mini": (0.15, 0.60),
    "o3-mini": (1.10, 4.40),
}

@dataclass
class CostTracker:
    model: str
    session_cost_usd: float = 0.0

    def estimate_prompt_cost(self, messages: list[dict]) -> float:
        """Pre-call estimation — not billing-accurate."""
        enc = tiktoken.encoding_for_model(self.model)
        tokens = sum(len(enc.encode(m["content"])) for m in messages)
        input_price, _ = PRICING[self.model]
        return tokens * input_price / 1_000_000

    def record_usage(self, usage) -> float:
        """Post-call — billing-accurate from response.usage."""
        input_price, output_price = PRICING[self.model]
        call_cost = (
            usage.prompt_tokens * input_price / 1_000_000
            + usage.completion_tokens * output_price / 1_000_000
        )
        self.session_cost_usd += call_cost
        return call_cost

client = OpenAI()
tracker = CostTracker(model="gpt-4o")

def agent_turn(messages: list[dict], budget_usd: float = 0.10) -> str:
    estimated = tracker.estimate_prompt_cost(messages)
    if tracker.session_cost_usd + estimated > budget_usd:
        raise RuntimeError(f"Budget exceeded: USD {tracker.session_cost_usd:.4f} + ~USD {estimated:.4f}")

    response = client.chat.completions.create(model=tracker.model, messages=messages)
    call_cost = tracker.record_usage(response.usage)
    print(f"Call: USD {call_cost:.4f} | Session: USD {tracker.session_cost_usd:.4f}")
    return response.choices[0].message.content

import OpenAI from 'openai'
import { getEncoding } from 'js-tiktoken' // npm i js-tiktoken

const PRICING: Record<string, [number, number]> = {
  'gpt-4o': [2.50, 10.00],
  'gpt-4o-mini': [0.15, 0.60],
}

class CostTracker {
  sessionCostUsd = 0

  estimatePromptCost(messages: OpenAI.ChatCompletionMessageParam[]): number {
    const enc = getEncoding('o200k_base')
    const tokens = messages.reduce((sum, msg) => {
      const text = typeof msg.content === 'string' ? msg.content : ''
      return sum + enc.encode(text).length
    }, 0)
    return (tokens * PRICING['gpt-4o'][0]) / 1_000_000
  }

  recordUsage(usage: OpenAI.CompletionUsage, model: string): number {
    const [inputPrice, outputPrice] = PRICING[model]
    const callCost =
      (usage.prompt_tokens * inputPrice) / 1_000_000 +
      (usage.completion_tokens * outputPrice) / 1_000_000
    this.sessionCostUsd += callCost
    return callCost
  }
}

const client = new OpenAI()
const tracker = new CostTracker()

async function agentTurn(
  messages: OpenAI.ChatCompletionMessageParam[],
  budgetUsd = 0.10
): Promise<string> {
  const estimated = tracker.estimatePromptCost(messages)
  if (tracker.sessionCostUsd + estimated > budgetUsd) {
    throw new Error('Session budget would be exceeded')
  }
  const res = await client.chat.completions.create({ model: 'gpt-4o', messages })
  if (res.usage) tracker.recordUsage(res.usage, 'gpt-4o')
  return res.choices[0].message.content ?? ''
}

import anthropic

CLAUDE_PRICING = {
    "claude-3-5-sonnet-20241022": (3.00, 15.00),
    "claude-3-haiku-20240307": (0.25, 1.25),
}

client = anthropic.Anthropic()

def estimate_claude_cost(model: str, messages: list[dict]) -> float:
    # Makes a lightweight API call, returns exact token count
    response = client.beta.messages.count_tokens(
        model=model,
        messages=messages,
        betas=["token-counting-2024-11-01"],
    )
    input_price, _ = CLAUDE_PRICING[model]
    return response.input_tokens * input_price / 1_000_000

import { ObservyzeClient } from '@observyze/sdk'
import OpenAI from 'openai'

const obs = new ObservyzeClient({
  apiKey: process.env.OBSERVYZE_API_KEY!,
  circuitBreaker: {
    maxExecutionBudgetUsd: 0.50,  // hard ceiling per session
    maxTurns: 20,                  // halt after 20 turns
    maxTokens: 200_000,            // halt at 200K cumulative tokens
  },
})

// All token tracking, cost accumulation, and budget enforcement
// happens automatically — throws BudgetExceededError when exceeded
const openai = obs.wrapOpenAI(new OpenAI())