llms.txt
Compare with other sites' llms.txt files →# 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. Add `.md` to a public page's path for its Markdown form, such as `https://telemetry.dev/docs/integrations/openai.md` or `https://telemetry.dev/docs/quickstart.md`. For the documentation homepage, use [docs/index.md](https://telemetry.dev/docs/index.md). Product pages outside `/docs` also answer `Accept: text/markdown`; documentation pages under `/docs` return HTML for that header, so use the `.md` URL there.
## How agents should use telemetry.dev
- For research, follow the `.md` links below. Each markdown page links onward with `.md` URLs.
- For setup instructions, SDK APIs, and the ingest contract, start from the [documentation index](https://telemetry.dev/docs/llms.txt). The whole documentation set is in [docs/llms-full.txt](https://telemetry.dev/docs/llms-full.txt).
- For all public product pages in one request, fetch [llms-full.txt](https://telemetry.dev/llms-full.txt).
- For the telemetry.dev API, read the [OTLP ingest reference](https://telemetry.dev/docs/reference/otlp.md), the [API key guide](https://telemetry.dev/docs/platform/api-keys.md), and the [OpenAPI description](https://telemetry.dev/openapi.json) 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. Capture settings cover telemetry only, not experiment outputs, dataset items, or saved prompt versions.
- **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.
- **Native Claude OpenTelemetry:** The [Claude SDK](https://telemetry.dev/docs/integrations/claude-sdk.md) sends its native spans through `@telemetry-dev/otel` or an OTLP exporter. The [Claude Platform](https://telemetry.dev/docs/integrations/claude-platform.md) sends its server spans to telemetry.dev as a Claude Console OpenTelemetry destination. When the two sources send a request's spans to the same project, telemetry.dev counts the token usage of that request one time. It matches the SDK span and the API span by request ID or response ID, so the API span does not have to be a child of the SDK span.
- **AI framework integrations:** Vercel AI SDK, TanStack AI, and Vercel Eve.
- **Coding-agent integrations:** [Cursor](https://telemetry.dev/docs/integrations/cursor.md) (`@telemetry-dev/cursor`), [opencode](https://telemetry.dev/docs/integrations/opencode.md) (`@telemetry-dev/opencode`), [Pi](https://telemetry.dev/docs/integrations/pi.md) (`@telemetry-dev/pi`), and [Oh My Pi](https://telemetry.dev/docs/integrations/omp.md) (`@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://api.telemetry.dev` (`https://ingest.telemetry.dev`, its earlier name, stays supported)
- Traces: `POST /v1/traces`
- Logs: `POST /v1/logs`
- Metrics: `POST /v1/metrics`
- Prompts: `GET /v1/prompts?name=<name>` with an optional `label` or `version` (the SDKs call it from `getPrompt` and `get_prompt`)
- Datasets: `GET /v1/datasets/{name}` gives the items of a dataset version, a page at a time
- Experiments that run in your code: `POST /v1/experiments`, then `POST /v1/experiments/{id}/items` with the outputs and `POST /v1/experiments/{id}/complete`; `GET /v1/experiments/{id}` gives the result
- Scores: `POST /v1/scores` records a score on a trace, a span, or a session, such as the feedback of a user
- Health: `GET /health`
- Authentication: `Authorization: Bearer <project API key>`
- API keys use the `td_live_...` prefix and can be scoped to one environment or all environments in a project.
- A key sends telemetry only when its Access has Send telemetry (the `telemetry:write` scope). Without it, ingest answers 403 with the message `This API key cannot send telemetry. Create a key with Send telemetry access.`
- A key fetches prompts only when its Access has Read prompts (the `prompts:read` scope). Without it, `GET /v1/prompts` answers 403 with the error code `insufficient_scope`.
- A key reads datasets, runs experiments, and sends scores only when its Access has Run experiments (the `datasets:read`, `experiments:write`, and `scores:write` scopes). Without it, the dataset, experiment, and score routes answer 403 with the error code `insufficient_scope`.
- 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 [integration directory](https://telemetry.dev/docs/integrations.md) links to provider, framework, coding-agent, SDK, and OpenTelemetry 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; 30,000 ingestion units per month, 14-day retention, 1 project, and 2 seats. No credit card is required.
- **Pro:** $25/month; 500,000 ingestion units per month, 30-day retention, 5 projects, and 5 seats.
- **Team:** $50/month; 2,000,000 ingestion units per month, 90-day retention, unlimited projects, unlimited seats, and priority support.
Prices are per workspace, 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 30,000 units per month, with 20% headroom: we reject an ingestion request if accepting it would bring the workspace's monthly total above 36,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
- [Documentation index](https://telemetry.dev/docs/llms.txt): Every documentation page with a summary. Each page has a `.md` form, and [docs/llms-full.txt](https://telemetry.dev/docs/llms-full.txt) holds the whole set.
- [Quickstart](https://telemetry.dev/docs/quickstart.md): Send a first trace with TypeScript or Python in five minutes.
- [Integration index](https://telemetry.dev/docs/integrations.md): Every supported SDK, framework, provider, coding agent, and OpenTelemetry setup guide.
- [TypeScript SDK](https://telemetry.dev/docs/sdk/typescript.md), [Python SDK](https://telemetry.dev/docs/sdk/python.md), and [OpenTelemetry](https://telemetry.dev/docs/sdk/opentelemetry.md): SDK references and how to connect an existing provider.
- [OTLP ingest API](https://telemetry.dev/docs/reference/otlp.md), [span attributes](https://telemetry.dev/docs/reference/span-attributes.md), and [cost calculation](https://telemetry.dev/docs/reference/cost.md): The ingest contract, recognized attributes, and how token usage becomes cost.
- [Full site content](https://telemetry.dev/llms-full.txt): All public product 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 telemetry.dev 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)
## Site pages
- [Home](https://telemetry.dev/index.md): Product overview and FAQ.
- [Product](https://telemetry.dev/features.md): What telemetry.dev does, with a link to each feature.
- [Cost tracking](https://telemetry.dev/features/cost.md): The cost of each model call, priced at ingest from its token usage, by model, provider, user, trace, and session, with budget and cost alerts.
- [MCP analytics](https://telemetry.dev/features/mcp.md): Methods, tools, and failures of your MCP traffic, from the client and the server.
- [Alerts](https://telemetry.dev/features/alerts.md): An email alert when cost or errors break from normal.
- [Prompt management](https://telemetry.dev/features/prompts.md): Versions, labels, and rollouts without a deploy.
- [Evals](https://telemetry.dev/features/evals.md): Trace each eval run, with its cost and errors. The Evals tab of a project also keeps datasets, runs experiments on them, and scores traces with LLM judges, code checks, rules, and reviewers.
- [Pricing](https://telemetry.dev/pricing.md)
- [Contact](https://telemetry.dev/contact.md): Support email and demo booking.
- [Alternatives](https://telemetry.dev/alternatives.md): How telemetry.dev compares with [LangSmith](https://telemetry.dev/alternatives/langsmith.md) and [Langfuse](https://telemetry.dev/alternatives/langfuse.md) on pricing, retention, OpenTelemetry, and evaluation.
- [Blog](https://telemetry.dev/blog.md): Guides on tracing and debugging AI agents.
- [Privacy policy](https://telemetry.dev/privacy.md)
- [Data processing addendum](https://telemetry.dev/dpa.md)
- [Subprocessors](https://telemetry.dev/subprocessors.md)
- [Terms](https://telemetry.dev/terms.md)
## Blog posts
- [AI Agent Monitoring: Measure Run Success and Latency](https://telemetry.dev/blog/ai-agent-monitoring-measure-run-success-and-latency.md): AI agent monitoring starts with run-level success rate and p50/p95 duration. Define success in your app, pick denominators, then drill into traces to find the slow step.
- [AI API Middleware: Trace App and Provider Boundaries](https://telemetry.dev/blog/ai-api-middleware-trace-app-and-provider-boundaries.md): AI API middleware explained for small TypeScript and Python teams: how it differs from an AI gateway and an observability backend, and how to trace each boundary.
- [Agent Telemetry: Trace Retries and Tool Failures](https://telemetry.dev/blog/agent-telemetry-trace-retries-and-tool-failures.md): Agent telemetry for production AI agents: an OpenTelemetry span hierarchy that separates a failed attempt from a failed run, with a retry wrapper example.
- [AI Cost Observability: Trace Spend to Agent Runs](https://telemetry.dev/blog/ai-cost-observability-trace-spend-to-agent-runs.md): AI cost observability for small teams: join reported token usage to traced calls and agent runs, and keep tokens, estimated cost and invoice as separate numbers.
- [LiteLLM Tracing: Correlate App and Gateway Requests](https://telemetry.dev/blog/litellm-tracing-correlate-app-and-gateway-requests.md): LiteLLM tracing guide: propagate W3C traceparent so your app and LiteLLM proxy spans share one trace, then verify with trace IDs and parent span links.
- [OpenTelemetry GenAI Prompt Capture: Inspect Before Export](https://telemetry.dev/blog/opentelemetry-genai-prompt-capture-inspect-before-export.md): OpenTelemetry GenAI prompt capture should be verified locally. Send synthetic prompts through a console exporter, read what lands on spans, and filter before export.
- [Claude Code Token Usage: Diagnose Missing Metrics](https://telemetry.dev/blog/claude-code-token-usage-diagnose-missing-metrics.md): Claude Code token usage chart empty or flat? Work through five ordered checks to tell a broken telemetry pipeline from a real zero or a bad query.
- [Bedrock Streaming Token Usage: Handle Incomplete Streams](https://telemetry.dev/blog/bedrock-streaming-token-usage-handle-incomplete-streams.md): Bedrock streaming token usage arrives in the final ConverseStream metadata event. Learn what a cancelled or dropped stream loses and how to record it honestly.
- [OpenTelemetry Collector Environment Variables for Auth](https://telemetry.dev/blog/opentelemetry-collector-environment-variables-for-auth.md): How to use ${env:VAR} in OpenTelemetry Collector environment variables to pass an API token to an OTLP/HTTP backend, plus 401/403 debugging without leaking secrets.
- [How to Trace Vercel AI SDK Calls with OpenTelemetry](https://telemetry.dev/blog/guides/how-to-trace-vercel-ai-sdk-calls-with-opentelemetry.md): Vercel AI SDK tracing from zero: register an OpenTelemetry provider, export OTLP/HTTP to telemetry.dev, and read model, tool, token and error spans.
- [How to debug slow AI agents with OpenTelemetry](https://telemetry.dev/blog/posts/debug-slow-ai-agents.md): Debug slow AI agents with an OpenTelemetry trace. Tell model latency, tool timeouts, and retrieval delays apart, and find the step to fix first.