What counts as an ingestion unit?

One normalized span, OTLP log record, or metric data point counts as one unit. A trace with five spans uses five units. Logs derived from span events and metric updates applied to existing spans do not add units.

What happens if I reach my plan's ingestion limit?

On Free, ingestion is rejected if accepting a request would exceed 36,000 units (30,000 plus 20% headroom) in a month. On paid plans, ingestion continues above the 500k (Pro) or 2M (Team) allowances with no automatic overage charges; if usage consistently exceeds the allowance, telemetry.dev will contact you to discuss a suitable plan.

Can I keep prompts and completions out of storage?

Yes, for recognized prompt, response, and tool-payload fields. Capture is on by default and can be disabled per environment before storage, but this doesn't stop transmission to ingest or remove arbitrary content from logs, errors, or custom attributes. Redaction patterns cannot catch all sensitive data.

Can I change plans or cancel anytime?

Yes. Upgrade, downgrade, or cancel whenever you need, billed per workspace, with no contracts and no cancellation penalties.

telemetry.dev — LLM observability for AI agents, built on OpenTelemetry

telemetry.dev is an LLM observability platform for AI applications and agents, built on OpenTelemetry. It groups instrumented model calls, tool steps, and retrievals into a single trace so developers can pinpoint slow steps, inspect failed calls, and monitor token usage, cost, latency, and errors. Teams can instrument their code with first-party TypeScript or Python SDKs, provider/framework integrations (OpenAI, Anthropic, Vercel AI SDK, and others), or any existing OTLP/HTTP exporter, without replacing their OpenTelemetry setup.

Key Features

Unified agent traces

Follow model calls, tool steps, and retrievals in one trace, with per-span duration to find the slow step or the failed call.

Cost and token tracking

Cost is computed at ingest from reported token usage and a model-pricing catalog, with separate rates for cache-read and cache-write tokens. Spend is broken down by model, provider, and environment.

Latency and error analytics

Compare latency (including p95), requests, and errors by model, provider, and environment across 7-day views.

MCP analytics

See spans, failures, and p95 duration by MCP method and tool, from both the client and the server.

Email alerts

Alerts for tool errors, monthly budgets, agent loops, and missing prices so you hear about problems before users do.

Prompt capture controls

Disable prompt and response capture per environment before storage, with built-in and project-specific redaction patterns.

OpenTelemetry-native ingestion

Accepts spans and logs via first-party SDKs or any standard OTLP/HTTP exporter, plus Claude SDK/API native OpenTelemetry spans.

Read-only MCP server for agents

Let your AI agent investigate errors, latency, and cost through telemetry.dev's read-only MCP server.

How It Works

Instrument your application

Create a project API key, then install a telemetry.dev integration (e.g. @telemetry-dev/openai, @telemetry-dev/ai-sdk, or the Python SDK) or configure any OTLP/HTTP exporter.

Send traces at ingest

Run an instrumented request; normalized spans, log records, and metric data points are ingested, each counting as one ingestion unit.

Inspect and act

Open a trace to inspect spans, attributes, and events; monitor cost, latency, and errors on dashboards; configure email alerts and per-environment prompt capture; or connect an AI agent via the read-only MCP server to investigate issues.

Pros & Cons

Pros

Built on OpenTelemetry, so existing OTLP/HTTP exporters work without lock-in
First-party SDKs for both TypeScript and Python, with integrations for major providers and agent frameworks
Cost computed at ingest with separate cache-read and cache-write token rates
Generous free tier (30k units/month, no credit card) and no automatic overage charges on paid plans
Per-environment prompt capture controls before storage, plus redaction patterns
Read-only MCP server that lets your own AI agents query telemetry data

Who It's For

Best for

Teams building AI agents and LLM applications who want OpenTelemetry-native tracing of model calls, tools, and retrievals
Developers who need to monitor token spend, latency, and error rates across multiple model providers
Teams running MCP-based tools who need per-method and per-tool failure analytics
Organizations that want prompt capture disabled in production while still capturing telemetry elsewhere

Not ideal for

Teams that need guaranteed full prompt/completion redaction from all data transmitted to the platform
Applications where the platform's model-pricing catalog doesn't cover the models in use and explicit span costs can't be set

Use Cases

Debugging failed or slow LLM calls and agent runs by inspecting per-span durations and model responses

Tracking and comparing LLM spend by model, provider, and environment against monthly budgets

Monitoring MCP tool reliability, including failure rates and p95 duration per method and tool

Getting email alerts for tool errors, agent loops, budget thresholds, and missing model prices

Keeping prompts and completions out of storage in sensitive environments like production

Pricing

Priced per workspace, per month, with a free tier requiring no credit card. Each normalized span, OTLP log record, or metric data point counts as one ingestion unit. Usage resets at 00:00 UTC on the first of each calendar month, independent of billing date. Paid plans have no automatic overage charges above their allowances. Plans can be upgraded, downgraded, or cancelled anytime with no contracts

Free

For a side project or a single service: 30k ingestion units/month, 14-day retention, 1 project, 2 seats.

Pro

$25

For growing applications: 500k ingestion units/month (ingestion continues above the amount, no automatic overage charges), 30-day retention, 5 projects, 5 seats.

Team

$50

For teams running AI in production: 2M ingestion units/month (ingestion continues above the amount, no automatic overage charges), 90-day retention, unlimited projects and seats, priority support.

FAQ

What is telemetry.dev?

An LLM observability platform for AI applications and agents, built on OpenTelemetry. A trace groups the instrumented model calls, tool steps, and retrievals in a request or agent run, with reported token usage, cost, latency, and errors for debugging and monitoring.

How do I start sending traces?

Create a project API key, then configure a telemetry.dev integration or an OTLP/HTTP exporter. Run an instrumented request and open its trace in your project; the integration directory links to setup instructions for each SDK, provider, and framework.

Which frameworks and languages are supported?

TypeScript and Python have first-party SDKs, with integrations for providers and frameworks such as OpenAI, Anthropic, and Vercel AI SDK. Claude SDK and Claude API can send native OpenTelemetry spans, and other languages can send standard OTLP over HTTP. Trace detail depends on what your instrumentation emits.

How is cost calculated?

telemetry.dev