Cursor · OpenTelemetry

Cursor OpenTelemetry

A practical guide to Cursor's OpenTelemetry export: available metrics and logs, configuration, privacy considerations, and what engineering teams can learn from the data.

Updated September 2026 · 10 min read

Cursor

AI code editor

OpenTelemetry

Export layer

Signals

Metrics
Logs

Compatible backend

Your observability stack

Quick answer

What is Cursor OpenTelemetry?

Cursor provides OpenTelemetry export for organizations that want to send AI coding usage and operational data to their own observability infrastructure. The exported telemetry can provide visibility into token consumption, estimated costs, model usage, tool calls, API requests, errors and agent activity.

Cursor currently exports OpenTelemetry metrics and logs. Distributed traces are not currently exported.

In short: Cursor OpenTelemetry makes AI coding usage observable outside Cursor using standard observability infrastructure.

Telemetry signals

What Telemetry Does Cursor Provide?

Cursor's OpenTelemetry export covers two of the three OpenTelemetry signal types.

Available
Metrics
Quantitative signals about Cursor usage, AI consumption and supported development activity, exported with delta temporality.
Available
Logs
Structured telemetry describing supported Cursor and agent activity, such as API requests, errors, skills, hooks, plugins and cloud agent events.
Not currently available
Traces
Cursor does not currently export distributed traces through its OpenTelemetry integration. Exported logs do not carry trace or span identifiers.

Telemetry reference

What Data Can Cursor Export?

Cursor's OpenTelemetry integration exposes signals across AI consumption, models, tools and agent workflows. Identifiers below come from Cursor's official OpenTelemetry Export documentation.

Cursor OpenTelemetry data categories, official identifiers and what they help observe
Data category	Signal	Official identifier	What it helps observe
Token usage	Metric	`cursor.token.usage`	AI token consumptionBroken down by cursor.token.type: input, output, cache_read and cache_creation.
Estimated costs	Metric	`cursor.cost.usage`	Estimated AI usage costsA best-effort USD estimate. Cursor documents that this is not an invoice; use the admin and billing APIs for billing.
Tool calls	Metric	`cursor.tool.calls`	Tools invoked during AI-assisted workflowsCovers builtin and MCP tools, distinguished by cursor.tool.kind.
API requests	Log	`cursor.api.request`	Supported API activityA model call summary, one log event per request.
Errors	Log	`cursor.api.error`	Operational errors and failuresAn error event. Cursor documents that raw error messages are not included.
Billing corrections	Log	`cursor.api.correction`	Usage finalizationBilling finalization events, joined on cursor.usage_event.id.
Skills	Log	`cursor.skill.activated`	Activity involving Cursor skillsEmitted when a skill is activated.
Hooks	Log	`cursor.hook.execution_complete`	Supported hook activityEmitted when a hook execution completes.
Plugins	Log	`cursor.plugin.installed`	Plugin-related activityEmitted when a plugin is installed.
Cloud Agents	Log	`cursor.cloud_agent.*`	Supported Cloud Agent eventsIncludes setup (started, completed, failed), artifact, pull_request (opened, creation_failed) and mcp_auth_error events.

Common attributes

service.name=cursor
Resource attribute identifying the exporting service.
cursor.team.id
Team the telemetry belongs to.
cursor.user.id
Optional user identifier, when the source provides it.
cursor.surface
Surface or entrypoint the activity came from.
cursor.event.id
Log dedupe key. Delivery for logs is at-least-once.
cursor.conversation.id
Session key shared across a run's log events.
cursor.usage_event.id
Request-grain key on api.request, api.error and api.correction.
cursor.token.type
input, output, cache_read or cache_creation on token metrics.

Use cases

What Can Engineering Teams Learn From Cursor Telemetry?

Cursor telemetry can help engineering organizations answer questions about adoption, AI consumption, models, tools and agent workflows.

Adoption & Usage
Understand how Cursor usage evolves across an engineering organization and identify broader adoption trends.
AI Consumption & Costs
Analyze token consumption and estimated costs to understand how AI usage evolves as adoption grows.
Models & Tools
Understand which models and tools participate in AI-assisted development workflows.
Agents & Workflows
Observe supported agent, skill, hook and plugin activity to better understand how Cursor participates in development workflows.
Usage and activity metrics provide context about AI-assisted development. They should not be treated as standalone measures of developer productivity.

How it works

How Cursor OpenTelemetry Works

Cursor can export supported telemetry using OpenTelemetry, allowing organizations to send AI coding data to compatible observability infrastructure. Export runs server-side and is delivered over OTLP/HTTP.

Cursor

OpenTelemetry

Metrics
Logs

OTLP

HTTP protobuf

Collector or compatible backend

Distributed traces: not currently exported

Read the official Cursor OpenTelemetry documentation

Configuration

How to Configure OpenTelemetry in Cursor

Cursor Enterprise organizations can configure OpenTelemetry export to send supported telemetry to their observability infrastructure. Admins set the destination in Team Settings, and the receiving collector accepts OTLP/HTTP protobuf on /v1/metrics and /v1/logs.

In Team Settings > OpenTelemetry Export, create a destination with the HTTPS base URL (no /v1 suffix — Cursor appends /v1/metrics and /v1/logs) and your auth headers, for example Authorization: Bearer <token>.
Use Test connection to verify the URL and authentication.
Enable the destination. Export starts within about a minute.

# Minimal OpenTelemetry Collector for Cursor's OTLP/HTTP protobuf export
receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  # Swap for your sink (datadog, clickhouse, logging, etc.)
  logging:
    verbosity: basic

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]

View advanced configuration

Transport — OTLP/HTTP binary protobuf only, POST to /v1/metrics and /v1/logs. gRPC and JSON are not supported.
Scope — Signals are emitted under the instrumentation scope cursor.telemetry 0.1.0.
Telemetry families — Each signal and family has its own toggle: model_usage, tool_calls, skills_hooks_plugins, cloud_agents and grok_bot_agent_actions. New families default on unless auto_enable_new_families is turned off.
Network reachability — The endpoint must be reachable from the public internet; Cursor egresses from a fixed set of static source IPs that can be allowlisted alongside TLS and auth.
Delivery semantics — Metrics are at-most-once and delta-only, so sum deltas per series. Logs are at-least-once — dedupe on cursor.event.id.
Backfill — There is no backfill from before the destination existed, and disabling or deleting a destination drops in-flight data.

Every metric, log event and attribute is listed in Cursor's Wire Reference.

Privacy

Privacy and Sensitive Data

AI coding telemetry can contain detailed information about how development tools are used. Organizations should understand which Cursor events and attributes are exported before enabling telemetry at scale.

AI Usage Data
Review which model, token and cost attributes are exported and retain only the telemetry required for your observability goals. Cursor documents that cost figures are best-effort estimates rather than billing records.
Tools & Agent Activity
Tool, agent, skill, hook and plugin telemetry can reveal details about development workflows and should be handled according to organizational policies. Each telemetry family has its own admin toggle in Team Settings.
Telemetry Destination
OpenTelemetry export allows organizations to send supported Cursor telemetry to their chosen compatible infrastructure. Cursor delivers OTLP over HTTPS from a fixed set of egress IPs, and stores destination headers encrypted.

Good practice: Collect the minimum telemetry required for the questions your organization wants to answer.

From telemetry to analytics

OpenTelemetry Gives You the Data. What Do You Do With It?

Cursor can provide detailed telemetry about AI consumption and development activity, but raw metrics and logs do not automatically explain how AI-assisted development is evolving across an engineering organization.

These signals still need to be structured and interpreted to understand broader patterns around adoption, costs, models, tools and agent workflows.

Turn Cursor Telemetry Into Engineering Intelligence

helloMetry transforms supported AI coding telemetry into structured analytics designed to help engineering organizations understand how AI is being adopted and used.

Adoption
AI Consumption
Costs
Agent Workflows

Explore Cursor with helloMetry

Overview

Last 7 days

2.842

AI Sessions+18%

312

Skill Usage+12%

18.672

Invocations+23%

€430

Est. Cost-8%

Activity over time

09:0013:1517:30

Time saved

156 h+26%

Tasks automated

1.284+19%

Skills breakdown

Code38%
Analysis24%
Writing18%
Research12%
Other8%

Active skills

48+9%

Success rate

96.2%+2%

Top skills

/code_review142 usages4.892
/debug98 usages3.210
/refactor85 usages2.761
/data_analysis74 usages2.104
/summarize68 usages1.874

Explore Other OpenTelemetry Integrations

Claude Code
Claude Code OpenTelemetry: metrics, events and traces, configuration and privacy considerations.
Read the guide
Gemini CLI
Gemini CLI OpenTelemetry: available metrics, logs and traces, setup and privacy considerations.
Read the guide
GitHub Copilot
GitHub Copilot OpenTelemetry: agent metrics, events and traces, setup and privacy considerations.
Read the guide

FAQ

Frequently Asked Questions

Does Cursor support OpenTelemetry?

Yes. Cursor provides OpenTelemetry export for supported telemetry, allowing organizations to send Cursor data to compatible observability infrastructure.

What data can Cursor export through OpenTelemetry?

Cursor's OpenTelemetry export can provide supported data about token consumption, estimated costs, models, tools, API activity, errors and agent-related workflows.

Does Cursor export OpenTelemetry traces?

No. Cursor currently exports metrics and logs through its OpenTelemetry integration, but does not currently export distributed traces.

Can Cursor token usage and costs be monitored?

Yes. Cursor exposes supported telemetry related to token consumption and estimated AI usage costs.

Is Cursor OpenTelemetry available to every customer?

Cursor's OpenTelemetry export is an Enterprise capability. Check Cursor's current documentation and plan availability for the latest requirements.

Does helloMetry replace OpenTelemetry?

No. OpenTelemetry provides the standard used to export telemetry. helloMetry uses supported telemetry to transform AI coding data into engineering analytics.

Cursor OpenTelemetry

Metrics

Logs

Traces

Common attributes

Adoption & Usage

AI Consumption & Costs

Models & Tools

Agents & Workflows

AI Usage Data

Tools & Agent Activity

Telemetry Destination