Send your agents’ OpenTelemetry to Proxon.

If your agent, service, or AI tool already emits OpenTelemetry, Proxon can read its model usage and cost directly — in any language, including server-side AI that never runs on anyone’s device, and tools that already speak OTLP like Claude Code and GitHub Copilot. There’s no new agent, no proxy, and no certificate: you mint a credential and set two standard OTLP environment variables. Proxon only needs the structured usage it attributes cost from — model and token counts — and you decide what your telemetry sends.

Set it up

Three steps, about five minutes. You'll mint a workspace credential, point your existing OpenTelemetry exporter at Proxon, and confirm the usage lands. You need to be a workspace owner or admin to mint the credential; anyone can wire the exporter once they have it.

Mint a service credential

In Proxon, open Settings → Service Credentials (under the Organization group) and choose Generate. Proxon issues a bearer token that starts with prx_svc_, scoped to your workspace.

The token is shown once — copy it and store it as a secret (an environment variable or your secrets manager). Proxon keeps only a hash, so it can’t show it to you again; if you lose it, rotate or generate a new one. You can revoke or rotate a credential from the same screen at any time.

Only workspace owners and admins see Service Credentials. If you don’t, ask an admin to mint one for you.

Point your OTLP exporter at Proxon

Set the two standard OpenTelemetry environment variables below. Any OTLP/HTTP exporter reads them on its own — there’s nothing Proxon-specific to import. Proxon accepts both an agent’s native OTLP and stock OpenTelemetry spans, in either JSON or protobuf encoding.

shell

# Point your OTLP/HTTP exporter at Proxon's traces endpoint.
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://ingest.proxon.ai/v1/traces"

# Authenticate with the service credential you minted in Step 1.
# The value is percent-encoded per the OTLP spec: Bearer%20<token> → Bearer <token>.
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="Authorization=Bearer%20prx_svc_<prefix>_<secret>"

# Optional — name the agent this telemetry belongs to (the rollup keys on it).
# Standard OTel: sets the service.name resource attribute Proxon reads.
export OTEL_SERVICE_NAME="my-agent"

Swap prx_svc_<prefix>_<secret> for the token from Step 1. That’s it — the next batch your exporter flushes lands in Proxon.

Confirm it landed

Turn on OpenTelemetry in Settings → Data Collection so Proxon shows the Agent Cost view, then open Cost Intelligence. Your agent’s spend appears there, broken down by model and by the agent name you set — usually within a minute of the first flush.

Proxon Cost Intelligence showing the otel-demo-gpt4o agent's spend, with a token breakdown and by-task-type, by-owner, and by-call-source splits. — An OTLP-instrumented agent (`otel-demo-gpt4o`) in Proxon Cost Intelligence — spend broken out by model, task type, and owner, reconstructed entirely from the gen_ai spans it exported.

Proxon turns each span into one usage row from the standard OTel GenAI attributes. Anything a normal GenAI instrumentation already sets is enough:

attributes Proxon reads

gen_ai.provider.name      # e.g. "anthropic" | "openai"
gen_ai.request.model      # e.g. "claude-opus-4-8" | "gpt-4o"
gen_ai.usage.input_tokens # integer
gen_ai.usage.output_tokens# integer
gen_ai.operation.name     # e.g. "chat"
proxon.agent              # optional — per-span agent name (overrides OTEL_SERVICE_NAME)

Proxon reads only the usage attributes it needs to attribute cost. Whatever else your spans carry is set by your own instrumentation — if you don’t want prompt or response text leaving your environment, keep it out of the telemetry you export.

SDK or OpenTelemetry?

The Proxon SDK and OpenTelemetry do the same job two ways. For a Node app you control, the Proxon SDK for Agents auto-instruments it with one line. For anything else — another language, or a tool that already emits OpenTelemetry — use this OTLP path. Either is enough on its own; running both adds detail, not new coverage. See how Proxon collects data for the full picture.