See every LLM call
Own your AI bill

Open-source LLM observability without a proxy. Find the prompt, customer, model, and workflow path behind every LLM cost spike — traced from inside your app, never routed through ours.

Quickstart Star on GitHub

Why no proxy matters

ScopeCall instruments your OpenAI / Anthropic / Vercel AI client in-process. Your app calls the provider directly — we observe the request and response without standing in the middle.

Zero added latency

The provider call is unchanged. The trace event is queued in-process and shipped out-of-band — never on the critical path.

No third-party in your data path

Prompts and responses never leave your infrastructure. Self-host the full ClickHouse + Postgres stack on your own hardware.

No vendor SPOF

If ScopeCall is down, your AI calls keep working. The provider request continues whether or not our ingest is reachable.

What you get

Every LLM call your app makes — captured, enriched, and queryable along the dimensions that explain your bill.

Trace every call

Prompt, response, tokens, latency, errors, finish reason, tool calls — all captured per call, indexed in ClickHouse.

Recompute cost server-side

The Rust processor recomputes cost from a bundled pricing table. Your dashboard's numbers are always correct, even if the SDK is wrong.

Streaming + TTFT

Time-to-first-token captured natively for streamed responses. See latency spikes upstream of user-perceived slowness.

Workflow spans

Wrap multi-step agents in sdk.trace(). Every LLM call inside becomes a child in the trace tree + Flow Map.

Prompt-version analytics

Tag each call with a prompt version. Compare cost, latency, and error rate across versions in one view.

PII redaction

Email, card, phone, SSN, IP patterns are stripped from prompts and responses before events leave your process.

Two lines of SDK. First trace in 60 seconds

Drop the SDK in front of your existing OpenAI / Anthropic client. No refactor, no middleware, no proxy URL.

TypeScript

$ npm install @scopecall/scopecall-js

import { init } from "@scopecall/scopecall-js";
import OpenAI from "openai";

const sdk = init({
  apiKey: process.env.SCOPECALL_API_KEY!,
  endpoint: "http://localhost:8080/v1/ingest",
});

const openai = new OpenAI();
sdk.instrument(openai);

// Every call through this client is now traced.
await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello" }],
});

Python

$ pip install "scopecall-py[openai]"

import os
import scopecall
from openai import OpenAI

sdk = scopecall.init(
    api_key=os.environ["SCOPECALL_API_KEY"],
    endpoint="http://localhost:8080/v1/ingest",
)

client = sdk.instrument(OpenAI())

with sdk.trace("hello-world"):
    client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "Hello"}],
    )

Full quickstart guide

ScopeCall vs the alternatives

What you actually trade when you pick each one. Honest comparison — we'll update this as the category evolves.

	ScopeCall	Langfuse	Helicone
Architecture	SDK in-process (direct)	SDK in-process	HTTP proxy
Adds latency to LLM calls			Proxy round-trip
Self-hostable
License	Apache 2.0	MIT (SDK) / AGPL-3.0 (server)	Apache 2.0 (mostly)
Server-recomputed cost
SDKs	TypeScript, Python	TypeScript, Python	TypeScript, Python, Go
Workflow spans (multi-step agents)

See an error in this table? Open an issue — we'd rather correct facts than win on stale ones.

Not another AI dashboard

ScopeCall is for debugging real production LLM calls — latency, cost, failures, and prompt behavior — from inside your app.

Star on GitHub Try it locally

See every LLM callOwn your AI bill