AI Monitoring built for debugging

Track LLM calls, token usage, model costs, and tool execution. Debug AI agents with full context on prompts, responses, and errors.

Select SDK

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [
    Sentry.openAIIntegration({
      recordInputs: true,
      recordOutputs: true,
    }),
  ],
});

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [
    Sentry.anthropicAIIntegration({
      recordInputs: true,
      recordOutputs: true,
    }),
  ],
});

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [Sentry.googleGenerativeAIIntegration()],
});

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [Sentry.langchainIntegration()],
});

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [Sentry.langGraphIntegration()],
});

Copied!Click to Copy// sentry.server.config.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [Sentry.vercelAIIntegration()],
});

Copied!Click to Copyimport sentry_sdk
from sentry_sdk.integrations.langchain import LangchainIntegration

sentry_sdk.init(
    dsn="___DSN___",
    traces_sample_rate=1.0,
    send_default_pii=True,
    integrations=[LangchainIntegration()],
)

Copied!Click to Copyimport sentry_sdk
from sentry_sdk.integrations.litellm import LiteLLMIntegration

sentry_sdk.init(
    dsn="___DSN___",
    traces_sample_rate=1.0,
    send_default_pii=True,
    integrations=[LiteLLMIntegration()],
)

Copied!Click to Copyimport sentry_sdk
from sentry_sdk.integrations.pydantic_ai import PydanticAIIntegration

sentry_sdk.init(
    dsn="___DSN___",
    traces_sample_rate=1.0,
    send_default_pii=True,
    integrations=[PydanticAIIntegration()],
)

Copied!Click to Copyconst Sentry = require("@sentry/node");

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [
    Sentry.openAIIntegration({
      recordInputs: true,
      recordOutputs: true,
    }),
  ],
});

Copied!Click to Copyconst Sentry = require("@sentry/node");

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [
    Sentry.anthropicAIIntegration({
      recordInputs: true,
      recordOutputs: true,
    }),
  ],
});

Copied!Click to Copyconst Sentry = require("@sentry/node");

Sentry.init({
  dsn: "___DSN___",
  tracesSampleRate: 1.0,
  integrations: [
    Sentry.googleGenAIIntegration({
      recordInputs: true,
      recordOutputs: true,
    }),
  ],
});

Select AI Provider

Copied!Click to Copy// app/api/chat/route.ts
import OpenAI from "openai";

const client = new OpenAI();

export async function POST(req: Request) {
  const response = await client.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: "Hello!" }],
  });
  return Response.json({ text: response.choices[0].message.content });
}

Copied!Click to Copy// app/api/chat/route.ts
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

export async function POST(req: Request) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello!" }],
  });
  return Response.json({ text: response.content[0].text });
}

Copied!Click to Copyconst { GoogleGenAI } = require("@google/genai");
const client = new GoogleGenAI({ apiKey: "..." });

const response = await client.models.generateContent({
  model: "gemini-2.0-flash",
  contents: "Hello!",
});

Copied!Click to Copy// app/api/chat/route.ts
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o" });

export async function POST(req: Request) {
  const response = await model.invoke("Hello!");
  return Response.json({ text: response.content });
}

Copied!Click to Copyconst { StateGraph, END } = require("@langchain/langgraph");
const { ChatOpenAI } = require("@langchain/openai");

const model = new ChatOpenAI({ model: "gpt-4o" });
const graph = new StateGraph({ channels: {} });
// Define your graph nodes and edges
const app = graph.compile();

const result = await app.invoke({ input: "Hello!" });

Copied!Click to Copy// app/api/chat/route.ts
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-4o"),
  prompt: "Hello!",
  experimental_telemetry: {
    isEnabled: true,
    recordInputs: true,
    recordOutputs: true,
  },
});

Copied!Click to Copyfrom anthropic import Anthropic
client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)

Copied!Click to Copyfrom langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o")
graph = StateGraph(dict)
# Define your graph nodes and edges
app = graph.compile()

result = app.invoke({"input": "Hello!"})

Copied!Click to Copyconst OpenAI = require("openai");
const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyconst Anthropic = require("@anthropic-ai/sdk");
const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyconst { GoogleGenAI } = require("@google/genai");
const client = new GoogleGenAI({ apiKey: "..." });

const response = await client.models.generateContent({
  model: "gemini-2.0-flash",
  contents: "Hello!",
});

Copied!Click to Copyconst { StateGraph, END } = require("@langchain/langgraph");
const { ChatOpenAI } = require("@langchain/openai");

const model = new ChatOpenAI({ model: "gpt-4o" });
const graph = new StateGraph({ channels: {} });
// Define your graph nodes and edges
const app = graph.compile();

const result = await app.invoke({ input: "Hello!" });

Copied!Click to Copyconst { generateText } = require("ai");
const { openai } = require("@ai-sdk/openai");

const result = await generateText({
  model: openai("gpt-4o"),
  prompt: "Hello!",
  experimental_telemetry: { isEnabled: true },
});

Copied!Click to Copyimport * as Sentry from "@sentry/react";
import OpenAI from "openai";

const openai = new OpenAI({ apiKey: "...", dangerouslyAllowBrowser: true });
const client = Sentry.instrumentOpenAiClient(openai, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyimport * as Sentry from "@sentry/react";
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({ apiKey: "...", dangerouslyAllowBrowser: true });
const client = Sentry.instrumentAnthropicAiClient(anthropic, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyimport * as Sentry from "@sentry/react";
import { GoogleGenAI } from "@google/genai";

const genai = new GoogleGenAI({ apiKey: "..." });
const client = Sentry.instrumentGoogleGenerativeAiClient(genai, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.models.generateContent({
  model: "gemini-2.0-flash",
  contents: "Hello!",
});

Copied!Click to Copyimport * as Sentry from "@sentry/react";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o" });
const sentryHandler = Sentry.createLangChainCallbackHandler();

const response = await model.invoke("Hello!", {
  callbacks: [sentryHandler],
});

Copied!Click to Copyimport * as Sentry from "@sentry/react";
import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o" });
const graph = new StateGraph({ channels: {} });
// Define your graph nodes and edges
const app = Sentry.instrumentLangGraphClient(graph.compile());

const result = await app.invoke({ input: "Hello!" });

Copied!Click to Copyimport * as Sentry from "@sentry/browser";
import OpenAI from "openai";

const openai = new OpenAI({ apiKey: "...", dangerouslyAllowBrowser: true });
const client = Sentry.instrumentOpenAiClient(openai, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyimport * as Sentry from "@sentry/browser";
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({ apiKey: "...", dangerouslyAllowBrowser: true });
const client = Sentry.instrumentAnthropicAiClient(anthropic, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }],
});

Copied!Click to Copyimport * as Sentry from "@sentry/browser";
import { GoogleGenAI } from "@google/genai";

const genai = new GoogleGenAI({ apiKey: "..." });
const client = Sentry.instrumentGoogleGenerativeAiClient(genai, {
  recordInputs: true,
  recordOutputs: true,
});

const response = await client.models.generateContent({
  model: "gemini-2.0-flash",
  contents: "Hello!",
});

Copied!Click to Copyimport * as Sentry from "@sentry/browser";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o" });
const sentryHandler = Sentry.createLangChainCallbackHandler();

const response = await model.invoke("Hello!", {
  callbacks: [sentryHandler],
});

Copied!Click to Copyimport * as Sentry from "@sentry/browser";
import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({ model: "gpt-4o" });
const graph = new StateGraph({ channels: {} });
// Define your graph nodes and edges
const app = Sentry.instrumentLangGraphClient(graph.compile());

const result = await app.invoke({ input: "Hello!" });

Tolerated by 4 million developers.

See everything in one dashboard.

Track all agent runs, error rates, LLM calls, tokens used, and tool executions. Monitor traffic patterns and duration metrics across your AI-powered features.

Learn More

Monitor spending across models.

Compare costs across different models. See token usage breakdown by model, track input vs output tokens, and identify expensive operations.

Learn More

Track agent tool calls and errors.

See which tools your agents call, their error rates, average duration, and P95 latency. Identify slow or failing tool executions before they impact users.

Learn More

Debug with full context.

Dive into individual requests with full prompt and response context. See AI spans with agent invocations, tool executions, token counts, costs, and timing.

AI Monitoring built for debugging

See everything in one dashboard.

Monitor spending across models.

Track agent tool calls and errors.

Debug with full context.

AI Monitoring FAQs

Which AI providers are supported?

What data is captured?

How do I enable prompt/response capture?

Does this work with agents and tool calls?

Start monitoring your AI agents