# telemetry.dev > LLM observability for AI agents and applications, built on OpenTelemetry. Trace instrumented model calls, tool steps, and retrievals. Inspect reported token usage, cost, latency, and errors. Connect through first-party TypeScript or Python SDKs, provider and framework integrations, or an existing OTLP/HTTP exporter. Use this index to find machine-readable pages. Every public product and documentation page on telemetry.dev has a markdown form at the same path with a `.md` suffix (for example `https://telemetry.dev/integrations/openai.md`). The same pages also answer `Accept: text/markdown`. ## How agents should use telemetry.dev - For research, follow the `.md` links below. Each markdown page links onward with `.md` URLs. - For all public product and documentation pages in one request, fetch [llms-full.txt](https://telemetry.dev/llms-full.txt). - For the ingest API, read the [OpenAPI description](https://telemetry.dev/openapi.json) and the authentication notes on the [developer page](https://telemetry.dev/developers.md) before sending data. - Paths under `/o/`, `/login`, `/signup`, and `/dashboard` are the interactive app and need a browser session. ## Product capabilities - **AI trace inspection:** View an instrumented request or agent run as a span hierarchy. Inspect model inputs and outputs, tool arguments and results, retrievals, errors, timing, and per-span attributes when the source instrumentation emits them. - **Search and filtering:** Search traces or individual spans and filter by status, environment, framework, user, or conversation. - **Usage dashboards:** Track requests, cost, p95 latency, input and output tokens, error rate, and OpenTelemetry metric series over 7-, 30-, or 90-day windows. Break down usage by model, provider, environment, user, or framework. - **Token and cost accounting:** Record input, output, cache-read, cache-write, and reasoning tokens when reported by the provider or instrumentation. telemetry.dev calculates cost at ingest from reported token usage and its model-pricing catalog. Cache-read and cache-write tokens use separate rates when available. Reasoning tokens are not charged separately. An explicit span cost takes precedence. Without matching model pricing or token usage, computed cost is unavailable. - **Streaming measurements:** Record end-to-end latency and time to first token when the integration exposes streaming timing. - **Correlated signals:** Store OTLP traces, logs, and metrics in the same project. Logs can carry trace and span context, and user IDs, conversation IDs, environments, and custom metadata can be propagated across a run. - **OpenTelemetry normalization:** Understand standard `gen_ai.*` semantic-convention attributes and normalize supported provider and framework telemetry into consistent model, provider, token, cost, and operation fields. - **Privacy controls:** Capture is on by default, and you can disable it per environment before storage. The switch drops recognized prompt, response, and tool-payload fields. It does not stop transmission to ingest or remove arbitrary content from logs, errors, or custom attributes. Built-in and project-specific redaction patterns apply, but pattern matching cannot catch all sensitive data. To prevent transmission, remove sensitive content in your instrumentation before export. - **Portable ingest:** Accept standard OTLP/HTTP as binary protobuf or OTLP/JSON from any language, OpenTelemetry SDK, or collector. Applications can use telemetry.dev SDKs, attach a telemetry.dev span processor to an existing OpenTelemetry provider, or configure an existing exporter. ## Integration coverage - **Core SDKs:** TypeScript/JavaScript (`@telemetry-dev/sdk`, Node >= 20.19 and supported edge runtimes) and Python (`telemetry-dev`, Python >= 3.10). - **Bring your own OpenTelemetry:** `@telemetry-dev/otel` provides a span processor and OTLP/protobuf trace exporter for applications that already configure their own OpenTelemetry provider. - **Provider SDK instrumentation:** OpenAI, Anthropic Claude, Google GenAI/Gemini, AWS Bedrock, and OpenRouter in TypeScript and Python; LiteLLM in Python. - **AI framework integrations:** Vercel AI SDK, TanStack AI, and Vercel Eve. - **Coding-agent integrations:** Cursor (`@telemetry-dev/cursor`), opencode (`@telemetry-dev/opencode`), Pi (`@telemetry-dev/pi`), and Oh My Pi (`@telemetry-dev/omp`) record agent turns, model calls, tool executions, subagents where supported, and lifecycle events. - **OpenTelemetry-based setup guides:** LangChain/LangGraph, Pydantic AI, CrewAI, Claude Code, OpenClaw, and Hermes Agent. - **Generic OpenTelemetry:** Any system that exports OTLP/HTTP as protobuf or JSON can send traces, logs, and metrics without a telemetry.dev SDK. Integration behavior varies by source. The individual guides document supported methods, streaming behavior, content capture, token fields, tool spans, and known limitations. ## Ingest and authentication - Base endpoint: `https://ingest.telemetry.dev` - Traces: `POST /v1/traces` - Logs: `POST /v1/logs` - Metrics: `POST /v1/metrics` - Health: `GET /health` - Authentication: `Authorization: Bearer ` - API keys use the `td_live_...` prefix and can be scoped to one environment or all environments in a project. - Full request and error contract: https://telemetry.dev/openapi.json A basic setup uses a project API key and a telemetry.dev integration or an OTLP/HTTP exporter. The [tracing setup guide](https://telemetry.dev/developers.md) links to provider, framework, and SDK instructions. Run an instrumented request, then flush the exporter before your process exits. Open the trace in your project to inspect its spans and reported usage. ## Hosting and product scope - telemetry.dev is a hosted service; self-hosted storage is not currently offered. - It is designed for applications that call models or run AI agents, rather than as a general-purpose replacement for all application performance monitoring. - The detail available in a trace depends on what the selected SDK, framework, provider, or OpenTelemetry instrumentation emits and on the project's content-capture settings. - OpenTelemetry is the transport and data foundation, so an existing OTel setup can be retained and exporters can be repointed without changing application-level instrumentation. ## Plans - **Free:** $0/month; 10,000 ingestion units per month, 7-day retention, 1 project, and 2 seats. No credit card is required. - **Pro:** $25/month founding price for the first 25 customers, locked for those customers; standard price is $50/month. Includes 250,000 ingestion units per month, 30-day retention, 5 projects, and 5 seats. - **Team:** $100/month; 1,000,000 ingestion units per month, 90-day retention, unlimited projects, unlimited seats, and priority support. Prices are per organization, per month. Each normalized span, OTLP log record, or metric data point uses one ingestion unit. Logs derived from span events and metric updates applied to existing spans do not add units. Free includes 10,000 units per month, with 20% headroom: we reject an ingestion request if accepting it would bring the organization's monthly total above 12,000 units. Usage resets at 00:00 UTC on the first day of each calendar month, independently of the billing date. Pro and Team ingestion continues above the included amounts, with no automatic overage charges. If usage consistently exceeds the allowance, we'll contact the customer to discuss a suitable plan. Current pricing and quota details are at https://telemetry.dev/pricing.md. ## Documentation - [Tracing setup guide](https://telemetry.dev/developers.md): OpenTelemetry setup, integration guides, ingest API, authentication, and content-capture limits. - [Integration index](https://telemetry.dev/integrations.md): Every SDK, framework, provider, and OpenTelemetry setup guide with a summary. - [Full site content](https://telemetry.dev/llms-full.txt): All public product, integration, and legal pages in one file. ## API and developer resources - [OpenAPI specification](https://telemetry.dev/openapi.json): Machine-readable OpenAPI 3.1 description of the ingest API. - [TypeScript SDK on npm](https://www.npmjs.com/package/@telemetry-dev/sdk) - [OpenTelemetry span processor on npm](https://www.npmjs.com/package/@telemetry-dev/otel) - [Python SDK on PyPI](https://pypi.org/project/telemetry-dev/) - [Machine-readable pricing](https://telemetry.dev/pricing.md): Plans, limits, and quotas. - [Sitemap](https://telemetry.dev/sitemap.xml) - [Support](mailto:support@telemetry.dev) ## Integration guides - [TypeScript SDK](https://telemetry.dev/integrations/typescript-sdk.md) — Pure TypeScript SDK for LLM traces, logs, and GenAI metrics. Works on Node and edge runtimes, built on OpenTelemetry with zero lock-in. - [Python SDK](https://telemetry.dev/integrations/python-sdk.md) — OpenTelemetry-native GenAI tracing, logs, and metrics for Python. Thin ergonomic functions over OTel spans, exported as OTLP protobuf. - [OpenTelemetry](https://telemetry.dev/integrations/opentelemetry.md) — Send standard OTLP traces, logs, and metrics from any language or framework. If it can emit OpenTelemetry, telemetry.dev can trace it. - [Anthropic](https://telemetry.dev/integrations/anthropic.md) — Wrap the Anthropic Claude SDK in TypeScript or Python. Messages, streams, tools, and thinking traced with tokens, cache usage, and cost. - [AWS Bedrock](https://telemetry.dev/integrations/aws-bedrock.md) — Instrument Bedrock Runtime and Agent Runtime in TypeScript or Python. Converse, InvokeModel, agents, flows, and knowledge bases traced with tokens and cost. - [Claude Code](https://telemetry.dev/integrations/claude-code.md) — Instrument Claude Code with its built-in OpenTelemetry export. Token usage, cost, sessions, and tool activity — no SDK, just environment variables. - [CrewAI](https://telemetry.dev/integrations/crewai.md) — Trace CrewAI runs with OpenLIT and standard OTLP/HTTP. Inspect agent and model spans with tokens, cost, and latency. - [Eve](https://telemetry.dev/integrations/eve.md) — Wire Vercel's Eve agent framework to telemetry.dev. Server traces, lifecycle logs, and client-side agent spans — one integration, three surfaces. - [Google Gemini](https://telemetry.dev/integrations/google-gemini.md) — Wrap the Google GenAI SDK in TypeScript or Python. Gemini generations, chats, streams, and embeddings traced with tokens, safety metadata, and cost. - [Hermes Agent](https://telemetry.dev/integrations/hermes.md) — Trace Hermes Agent with the community hermes-otel plugin. LLM calls, tool executions, sub-agents, and token metrics over OTLP — config only, no code changes. - [LangChain / LangGraph](https://telemetry.dev/integrations/langchain.md) — Trace LangChain and LangGraph runs over OpenTelemetry. Capture every chain, model call, and tool step with tokens, cost, and latency. - [LiteLLM](https://telemetry.dev/integrations/litellm.md) — Instrument litellm.completion, embeddings, streaming, and Router calls in Python. One span per call across 100+ providers, with tokens and cost. - [Model Context Protocol](https://telemetry.dev/integrations/model-context-protocol.md) — Trace MCP client and server requests across stdio and Streamable HTTP. See tool calls, prompts, resources, latency, errors, and distributed context in one trace. - [OpenAI](https://telemetry.dev/integrations/openai.md) — Wrap the official OpenAI SDK in TypeScript or Python. Chat completions, the Responses API, streams, and embeddings traced with tokens and cost. - [OpenClaw](https://telemetry.dev/integrations/openclaw.md) — Connect OpenClaw's built-in OpenTelemetry exporter. Agent runs, model calls, tool executions, token usage, and cost — config only, no code changes. - [OpenRouter](https://telemetry.dev/integrations/openrouter.md) — Wrap the official OpenRouter SDK in TypeScript or Python. Chat, Responses, streams, and embeddings traced with tokens, provider-reported cost, and latency. - [Pydantic AI](https://telemetry.dev/integrations/pydantic-ai.md) — Send Pydantic AI agent and model spans to telemetry.dev over OpenTelemetry, with native GenAI token, cost, and latency fields. - [TanStack AI](https://telemetry.dev/integrations/tanstack-ai.md) — A chat() middleware for TanStack AI. Every run traced as agent loops, model steps, and tool calls — with tokens, cost, and conversation grouping. - [Vercel AI SDK](https://telemetry.dev/integrations/vercel-ai-sdk.md) — Native telemetry integration for the Vercel AI SDK. Every generateText, streamText, agent loop, and tool call traced with tokens, cost, and latency. ## Site pages - [Home](https://telemetry.dev/index.md): Product overview and FAQ. - [Pricing](https://telemetry.dev/pricing.md) - [Contact](https://telemetry.dev/contact.md): Support email and demo booking. - [Privacy policy](https://telemetry.dev/infopages/privacy.md) - [Data processing addendum](https://telemetry.dev/infopages/dpa.md) - [Subprocessors](https://telemetry.dev/infopages/subprocessors.md) - [Terms](https://telemetry.dev/infopages/terms.md)