Pricing

Every LLM span carries a per-span cost in USD. The SDK never hardcodes prices: you report token counts (or a final cost), and Trodo computes the dollars from prices you control. This works on every ingestion path, the SDKs and OTLP /v1/traces alike.

How cost is resolved

Each LLM span takes its cost from the first source that applies, in priority order:

In detail:

1. Explicit cost: a final USD number you send. Used as-is, never recomputed.
2. Token pricing: you send token counts and Trodo prices them, using your team's configured Model Price (Configuration → Model Price), then Trodo's built-in default, then left unset if the model is unknown.

Prices apply going forward. Changing a price affects new spans only; it does not retroactively recompute past runs.

Token categories

Tokens live in an open usage_details map. input and output are the defaults; you can also price cache_read, cache_write, reasoning, audio, image, or any custom key. Raw provider field names are accepted and normalised server-side:

A custom category is only priced if its key matches a category you add in the Model Price UI.

Report cost from the SDK

The llm helper and auto-instrumentation capture usage for you, including cache and reasoning tokens, so most of the time you send nothing extra. When you need control, trackLlmCall and setLlm accept several forms.

// (a) Tokens only — priced from the model name; cache tokens captured automatically.
const answer = trodo.llm('answer', callAnthropic, {
  model: 'claude-sonnet-4', provider: 'anthropic',
});

// (b) Raw provider usage object — auto-normalised.
await trodo.trackLlmCall({
  model: 'gpt-4o', provider: 'openai',
  usage: resp.usage,                 // { prompt_tokens, completion_tokens, prompt_tokens_details: { cached_tokens } }
  prompt: body, completion: resp,
});

// (c) Explicit usage map + cache shorthands.
await trodo.trackLlmCall({
  model: 'claude-sonnet-4', provider: 'anthropic',
  usageDetails: { input: 1000, output: 500 },
  cacheReadTokens: 200, cacheWriteTokens: 80,
});

// (d) Pin the final cost (skips server-side pricing).
await trodo.trackLlmCall({ model: 'gpt-4o', provider: 'openai', cost: 0.0123 });

// (e) Record a per-category cost breakdown.
await trodo.trackLlmCall({
  model: 'gpt-4o', provider: 'openai',
  costDetails: { input: 0.0003, output: 0.0005, cache_read: 0.00001 },
});

// Inside a manual span:
span.setLlm({ model: 'gpt-4o', provider: 'openai', usageDetails: { input: 1000, output: 500 }, cacheReadTokens: 200 });

# (a) Tokens only — priced from the model name; cache tokens captured automatically.
answer = trodo.llm('answer', call_anthropic, model='claude-sonnet-4', provider='anthropic')

# (b) Raw provider usage object — auto-normalised.
trodo.track_llm_call(model='gpt-4o', provider='openai', usage=resp['usage'],
                     prompt=body, completion=resp)

# (c) Explicit usage map + cache shorthands.
trodo.track_llm_call(model='claude-sonnet-4', provider='anthropic',
                     usage_details={'input': 1000, 'output': 500},
                     cache_read_tokens=200, cache_write_tokens=80)

# (d) Pin the final cost (skips server-side pricing).
trodo.track_llm_call(model='gpt-4o', provider='openai', cost=0.0123)

# (e) Record a per-category cost breakdown.
trodo.track_llm_call(model='gpt-4o', provider='openai',
                     cost_details={'input': 0.0003, 'output': 0.0005, 'cache_read': 0.00001})

# Inside a manual span:
s.set_llm(model='gpt-4o', provider='openai',
          usage_details={'input': 1000, 'output': 500}, cache_read_tokens=200)

Fields

trackLlmCall / track_llm_call and setLlm / set_llm accept:

To override how the llm helper reads usage, pass extractUsage (scalar in/out) or extractUsageMap (open map) in its options.

Configure model prices in the app

No code required. In the app, go to Configuration → Model Price.

• Add a model by name and set USD-per-1,000-token prices for any category: Input, Output, Cache Read, Cache Write, or a custom key. Match a model by exact name or by prefix, and optionally scope a rule to one provider (leave it blank to match any).
• Auto-detected models — models seen in your spans (last 30 days) with no rule appear automatically tagged Unpriced. Open one and set prices to start pricing it; nothing is stored until you save.
• Aliases and merge — fold model-name variants (for example gpt-4o-2024-11-20) under one canonical model so they're priced and charted together.
• Priority — when more than one rule could match, the most specific wins (exact over prefix, provider-specific over any-provider), with priority breaking ties.
• Drill-down — open a model to see its calls, cost, latency (average and p95), tokens, and error rate over time.

Via the API

The same rules are available at /api/config/model-prices for automation:

A rule is { provider?, model_pattern, match_type, prices: { input, output, cache_read, … }, priority, aliases }. Every change is written to an append-only history for audit and rollback.

Run rollups

Each run sums its spans into total_cost, and merges the per-category breakdowns into total_cost_details, so a run's cost always matches the spans that explain it.

Next

• Add manual spans for setLlm and the llm helper
• Raw HTTP / non-OTel clients for trackLlmCall