# telemetry.dev > Observability for AI and LLM apps. Every model call, tool step, and retrieval lands in one OpenTelemetry trace with tokens, cost, latency, and errors attached. First-party TypeScript and Python SDKs, a drop-in Vercel AI SDK integration, and standard OTLP/HTTP ingest for everything else. 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 computes cost server-side from token usage and current pricing for 8,600+ model identifiers, while preserving explicit cost values when supplied. - **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:** Prompt and response capture can be enabled or disabled per environment. Common secrets are redacted during ingest before storage, and projects can define custom redaction patterns. Content capture is enabled by default unless configured otherwise. - **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 consists of creating a project API key, installing the relevant integration or configuring an OTLP/HTTP exporter, and sending data to the corresponding `/v1` endpoint. ## 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. Each span, log record, or metric data point uses one ingestion unit. On Free, a trace request that would raise the monthly span count above 12,000 may be rejected; log and metric ingestion continues. Pro and Team limits are soft, so ingestion continues above the included monthly amount. Current pricing and quota details are maintained at https://telemetry.dev/pricing.md. ## Documentation - [Developer overview](https://telemetry.dev/developers.md): Ingest API, authentication, quickstart, and versioning policy. - [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. - [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)