Ctrlk
API DOCS
For the complete documentation index, see llms.txt. This page is also available as Markdown.

AI Assistant Data Reference

Complete reference of all data points collected from AI assistant integrations, including Claude Code, Gemini CLI, Cursor IDE, Claude Cowork, Codex CLI, and GitHub Copilot.

This page documents every data point that Revenium collects from AI coding assistant integrations. Use this reference to understand exactly what telemetry is captured, how it's used, and what privacy guarantees apply.

How Data Is Collected

All AI coding assistant data is collected via OpenTelemetry (OTLP) log records. Each coding tool has a dedicated integration that exports usage telemetry to Revenium's OTLP endpoint. No proprietary agents or background processes are involved — data flows through the standard OpenTelemetry protocol.

Tool
Integration Method
Data Flow

Claude Code

@revenium/cli npm package

Claude Code hooks → OTLP logs → Revenium

Gemini CLI SDK

@revenium/cli npm package

Gemini CLI → OTLP logs → Revenium

Cursor IDE

Admin API sync

Cursor Admin API → Revenium (periodic)

Claude Cowork

Admin UI (OTLP)

Claude for Work admin → OTLP logs → Revenium

Codex CLI

@revenium/cli npm package

Codex CLI → OTLP logs → Revenium

GitHub Copilot

Admin API sync

GitHub Copilot Admin API → Revenium (periodic)

Agent Identifiers

Each tool is identified by an agent value in the telemetry:

Tool
Agent Identifier

Claude Code

claude-code

Gemini CLI

gemini-cli

Cursor IDE

cursor-ide

Claude Cowork

claude-cowork

Codex CLI

codex-cli

GitHub Copilot

github-copilot

Data Privacy

Revenium never collects your code, prompts, or conversation content. Only usage metadata is transmitted — token counts, model names, timestamps, and session identifiers. This applies to all integrations by default.

Specifically, the following are never sent in the default configuration:

  • Source code or file contents

  • Prompt text or system prompts

  • AI response content

  • API keys, credentials, or secrets

  • Repository names or git history (diffs, commits, file contents)

  • Screen content or clipboard data

GitHub Integration Data (Optional)

The following section applies only when the optional GitHub integration is connected. Without it, the AI Coding Dashboard operates entirely from OTLP telemetry data and does not interact with GitHub in any way.

What We Read from GitHub

When the integration is active, Revenium makes the following read-only API calls to GitHub:

Data Read
Purpose

Organization member list (usernames, public emails)

Auto-map developers to their corporate email

Public user profiles and email search

Resolve GitHub logins to email addresses for attribution

Repository names in the organization

Determine which repos to scan for merged PRs

Merged PR metadata (author, merge date)

Count PRs merged per developer in the selected period

Commit messages and commit author emails

Detect AI co-author patterns (e.g. Co-Authored-By trailers)

Revenium reads commit messages only to detect AI co-authorship. From each commit it retains the Co-authored-by: trailer lines from the message and the commit author email addresses, kept for up to 120 days after the pull request is merged, so that attribution can be recomputed when you change your detection patterns. The rest of the message is discarded, and file contents, diffs, and patches are never read.

What We Store

Stored Data
Description

Daily PR counts per developer

Number of PRs merged and number of AI-assisted PRs, per day

GitHub-to-email mappings

Links each developer's GitHub username to their corporate email for attribution

Per-PR attribution evidence

For each merged pull request: GitHub organization and repository name, PR number, merge date, author login, commit count, commit author email addresses, and the Co-authored-by: trailer lines. Retained for 120 days after the pull request is merged, so attribution can be recomputed when detection patterns change

What We Do NOT Access

Even though the GitHub token may have broad permissions (repo scope), our implementation only makes the specific API calls listed above. The following are never accessed:

  • File contents, diffs, or patches

  • Pull request descriptions or comments

  • Repository source code

  • Issues, reviews, or branch data

  • GitHub Actions, webhooks, or deployment data

  • Private user profile data beyond public email

Token Permissions

The GitHub integration uses a fine-grained personal access token with three read-only permissions: Pull requests and Metadata at the repository level, plus Members at the organization level. Classic tokens using repo and read:org are still accepted, but repo grants write access to all repository content and is far broader than Revenium needs.

Revenium never reads repository file contents. There are no calls to the Contents API, git trees or blobs, archive downloads, code search, pull request file diffs, or commit patches.

For details on setting up and configuring the GitHub integration, see GitHub Integration.

Common Data Points

The following data points are collected by all AI coding assistant integrations. These form the core telemetry schema that powers the AI Coding Dashboard.

Token Metrics

Data Point
Type
Description

inputTokenCount

Integer

Number of input tokens consumed in the request

outputTokenCount

Integer

Number of output tokens generated by the model

cacheReadTokenCount

Integer

Tokens served from the model's prompt cache (reduces cost)

cacheCreationTokenCount

Integer

Tokens written to the model's prompt cache

reasoningTokenCount

Integer

Extended thinking / chain-of-thought tokens (model-dependent)

totalTokenCount

Integer

Sum of all token types for the request

Cost Metrics

Data Point
Type
Description

totalCost

Decimal

Calculated cost in USD for this request, based on model pricing

cost_source

String

Always coding_assistant for AI coding tool traffic

costType

String

Always AI for AI coding assistant requests

Model & Provider Identity

Data Point
Type
Description

model

String

AI model name (e.g., claude-opus-4-5-20251101, gemini-2.5-pro, codex-mini-latest)

provider

String

AI provider identifier. Set by backend mappers: ClaudeCode, GeminiCli, CursorIde, ClaudeCowork, CodexCli.

agent

String

Coding assistant identifier (claude-code, gemini-cli, cursor-ide, claude-cowork, codex-cli, github-copilot)

Timing

Data Point
Type
Description

requestTime

Timestamp

When the request was initiated (ISO 8601 / epoch nanoseconds)

requestDuration

Integer

Total request duration in milliseconds

Attribution

Data Point
OTLP Attribute
Type
Description

subscriber

user.email

String

Developer email address for usage attribution (optional, user-configured)

organizationName

organization.id or organization.name

String

Organization or company name/ID for cost rollup (optional). The backend prefers organization.name; falls back to organization.id.

productName

product.id or product.name

String

Product or project name/ID for cost rollup (optional). The backend prefers product.name; falls back to product.id.

traceId

session.id

String

Session identifier — groups requests within a single coding session

transactionId

transaction_id

String

Unique identifier for each individual request (used for deduplication)

The Data Point column shows the name as stored in the analytics database. The OTLP Attribute column shows the key name in the raw telemetry payload. The backend mapper translates between these formats during ingestion.

Operational Classification

Data Point
Type
Description

operationType

String

Request classification (e.g., CHAT)

stopReason

String

Why the model stopped generating. Revenium enum values: END, TOKEN_LIMIT, ERROR, CANCELLED. See Gemini Stop Reason Mapping and Codex CLI Stop Reason Mapping for tool-specific normalization.

errorReason

String

Error description if the request failed (empty on success)

Coding Assistant Account Linkage

Data Point
Type
Description

coding_assistant_account_uuid

String

Links telemetry to a specific coding assistant account for cross-session tracking

subscription_tier

String

Subscription plan identifier (see Subscription Tiers below)

Claude Code Data Points

In addition to the Common Data Points above, Claude Code captures the following:

Subscription Tiers

Claude Code subscriptions tiers are optionally tracked when using the Revenium SDKs:

Tier
Description

pro

Anthropic Pro plan

max_5x

Anthropic Max 5x plan

max_20x

Anthropic Max 20x plan

team_premium

Anthropic Team Premium plan

enterprise

Anthropic Enterprise plan

api

Direct API usage (full API pricing, no subscription discount)

Data Collection Modes

Claude Code supports two data collection modes:

Mode
Description

Real-time

Telemetry is exported automatically during each Claude Code session via OTLP hooks. Captures core token, cost, and timing metrics.

Backfill

The revenium-metering backfill command scans local Claude Code session logs (~/.claude/projects/) and sends historical usage data.

Backfill is idempotent — it is safe to re-run at any time, and duplicate records are prevented automatically.

Centralized Claude Code Configuration

For team-wide real-time telemetry, configure Claude Code once with managed settings instead of asking every developer to run local setup.

Approach
Best for
Where configured

Server-managed settings

Claude Teams or Enterprise organizations without MDM, or with unmanaged developer devices

Claude.ai → Admin Settings → Claude Code → Managed settings

Endpoint-managed settings

Organizations with MDM, device-management, registry policy, or system-level managed-settings deployment

macOS managed preferences, Windows policy/registry, or system managed-settings.json

Per-developer CLI setup

Individual developers, third-party Anthropic providers, one-off setup, or historical backfill

@revenium/cli on each machine

Organization-Wide Setup

Claude Code supports centrally-managed configuration through the Claude admin console. An administrator defines the settings once; Anthropic delivers them to every authenticated user on next startup. No per-developer install is required. Please see Setup Claude Code

Gemini Data Points

Gemini CLI data flows into Revenium via the @revenium/cli npm package, which configures Gemini CLI's native OTLP export to send telemetry to Revenium's endpoint.

Gemini CLI SDK Data Points

The CLI SDK captures the Common Data Points listed above — token metrics, cost, model identity, timing, and attribution.

Gemini CLI operates in real-time only — there is no backfill capability. Telemetry is captured and exported as each Gemini CLI request completes.

Stop Reason Mapping

Gemini CLI normalizes Google's finish reasons to Revenium's supported StopReason value:

Gemini Finish Reason
Revenium StopReason
Description

STOP

END

Normal completion

MAX_TOKENS

TOKEN_LIMIT

Token limit reached

SAFETY, BLOCKLIST, PROHIBITED_CONTENT, SPII, MODEL_ARMOR

ERROR

Content safety filter triggered

RECITATION, IMAGE_SAFETY, IMAGE_PROHIBITED_CONTENT, IMAGE_RECITATION

ERROR

Recitation or image safety filter

MALFORMED_FUNCTION_CALL, UNEXPECTED_TOOL_CALL, NO_IMAGE

ERROR

Tool call or image error

CANCELLED / CANCELED

CANCELLED

Request canceled

FINISH_REASON_UNSPECIFIED, OTHER, IMAGE_OTHER

(caller-supplied default)

Returns the default stop reason provided by the calling context

Cursor IDE Data Points

In addition to the Common Data Points above, Cursor IDE captures the following through its Admin API sync:

Billing Classification

Data Point
Type
Description

billing.kind

String

Cursor billing classification (Included, Premium, etc.) — determines whether usage counts against quota

operation_type

String

Operation type from Cursor (e.g., request classification)

stop_reason / finish_reason

String

Finish reason from Cursor

When billing.kind is Included, Revenium sets billingSkipped = true, skipReason = FREE_TIER, and forces totalCost to null — indicating the request was covered by the subscription and incurred no additional cost.

Setup Model

Cursor is configured through the Revenium dashboard: paste your Cursor team API key in Connections > Providers > Cursor and the backend syncs usage automatically every 5 minutes. No CLI installation or per-machine setup is required. A team API key is required (not a personal user key) because Revenium pulls from the /teams/filtered-usage-events endpoint.

For step-by-step instructions and troubleshooting, see Setup Cursor.

Data Collection Mode

Cursor IDE usage data is collected periodically from Cursor's Admin API. Unlike Claude Code and Gemini CLI, data is not captured in real-time during each request — it is synced at regular intervals from Cursor's team usage API.

Claude Cowork Data Points

In addition to the Common Data Points above, Claude Cowork captures the same telemetry schema as Claude Code — token metrics, cost, model identity, timing, and attribution. Cowork traffic is identified by the ClaudeCowork provider and the claude-cowork agent identifier, and surfaces on its own Claude Cowork dashboard under AI Assistants.

Setup Model

Claude Cowork is enterprise / organization-administered — not a per-user install. An organization administrator enables OTLP export once from the Claude for Work admin console (Organization → Co-work → Monitoring, reachable from the Claude desktop app or claude.ai in a browser), pointing Cowork at Revenium's OTLP endpoint with a metering key (rev_mk_*). Anthropic then exports telemetry for every authenticated Cowork user in the organization — there is no @revenium/cli install and no per-machine setup.

For step-by-step admin instructions, the exact configuration values, and troubleshooting, see Setup Claude Cowork.

Data Collection Mode

Claude Cowork operates in real-time only — there is no backfill capability. Telemetry is captured and exported as each Cowork request completes.

Billing Classification

Claude Cowork is metered by usage (provider-metered) rather than seat-based. The AI Assistant pricing mode team setting controls whether Cowork telemetry counts as real API spend in Revenium-wide reporting or stays scoped to AI Assistant analytics.

Codex CLI Data Points

In addition to the Common Data Points above, Codex CLI data is captured through the @revenium/cli npm package, which configures Codex CLI's native OTLP export to send telemetry to Revenium's endpoint.

Data Collection Mode

Codex CLI captures telemetry in real time, exported as each Codex CLI request completes, and also supports backfill of historical sessions via revenium-codex backfill. All Codex CLI traffic surfaces in Revenium under the unified CodexCli provider.

Stop Reason Mapping

Codex CLI normalizes OpenAI's finish_reason values to Revenium's supported StopReason enum:

OpenAI Finish Reason
Revenium StopReason
Description

stop

END

Normal completion

length

TOKEN_LIMIT

Token limit reached

content_filter

ERROR

Content safety filter triggered

tool_calls

END

Model returned a tool/function call (treated as a normal stop)

(missing / other)

(caller-supplied default)

Returns the default stop reason provided by the calling context

GitHub Copilot Data Points

In addition to the Common Data Points above, GitHub Copilot is exposed in the AI Assistants UI under the github-copilot agent identifier.

Status: GitHub Copilot usage is collected by the Revenium CLI from GitHub's organization-level Copilot APIs and exported to Revenium over OTLP. The backend recognizes this telemetry and maps it to the github-copilot agent, so Copilot activity appears in the AI Assistants UI alongside the other assistants on this page. Copilot records carry cost, model and organization attribution. GitHub's organization reports do not carry per-request token counts, prompt-cache detail, session identifiers or request timing, so those Common Data Points are not populated for Copilot.

Data Collection Mode

GitHub Copilot usage data is collected periodically from GitHub's organization-level Copilot APIs and exported to Revenium via OTLP, mirroring the Cursor IDE flow. Data is not captured in real time during each request. It is synced at regular intervals from GitHub's administrative endpoints.

Derived Fields

The following fields are not sent by the SDKs but are calculated by the Revenium backend during ingestion:

Field
Derivation
Description

inputTokenCost

inputTokenCount × model_input_cost_per_token

Cost attributed to input tokens

outputTokenCost

outputTokenCount × model_output_cost_per_token

Cost attributed to output tokens

cacheCreationTokenCost

cacheCreationTokenCount × model_cache_creation_cost

Cost attributed to cache creation

cacheReadTokenCost

cacheReadTokenCount × model_cache_read_cost

Cost attributed to cache reads

totalCost (when not provided)

Sum of all token costs

Calculated when SDK sends zero or null cost

apiKey

Extracted from x-api-key HTTP header

Authentication key for tenant identification

credentialId

Extracted from subscriber JSON

Credential identifier for access control

OTLP Transport Details

For teams implementing custom integrations or verifying data flow, here are the OTLP transport details:

Endpoint

Where base_url is typically https://api.revenium.ai/meter/v2/otlp.

Authentication

This is a metering key (rev_mk_*) — sufficient for OTLP telemetry ingest, which is what every AI coding-assistant integration on this page does. For workflows that also report business outcomes or manage Revenium resources, use a write-scope key (rev_sk_*) — see API Key Permissions.

Payload Format

All integrations use the OTLP/HTTP JSON format (application/json):

The example above shows a Claude Code backfill payload with the core token attributes. The real-time test/connectivity payload (via revenium-metering test in each relevant SDK if used) uses stringValue for token fields and additionally sends cost_usd and duration_ms. Gemini CLI and Codex CLI payloads follow the same OTLP structure with service.name set to gemini-cli / codex-cli and scope name set to gemini_cli / codex_cli. Cursor IDE is exported on the same OTLP transport after Revenium pulls it from Cursor's Admin API; GitHub Copilot follows the same pattern, exported over OTLP after the Revenium CLI pulls it from GitHub's Copilot APIs.

Related Documentation

PreviousSetup Codex CLI
NextSkill Origin Classification

Last updated

Was this helpful?