sentry_list_organization_replays

Retrieve and analyze user session replays from Sentry to monitor interactions, errors, and experience issues for debugging and performance monitoring.

Instructions

List replays from a Sentry organization. Monitor user sessions, interactions, errors and experience issues.

Input Schema

TableJSON Schema

Name	Required	Description
`project`	No	Project ID or slug
`limit`	No	Number of replays to return
`query`	No	Search query

Implementation Reference

src/index.ts:1279-1302 (handler)

MCP tool handler implementation that extracts parameters (project, limit, query), constructs params object, calls apiClient.listReplays(), and formats the response with replay details.

case "sentry_list_organization_replays": {
  if (!apiClient) {
    throw new Error("Sentry API client not initialized. Provide auth token.");
  }
  
  const { project, limit = 50, query } = args as any;
  const params: any = { limit };
  if (project) params.project = project;
  if (query) params.query = query;
  
  const replays = await apiClient.listReplays(params);
  
  return {
    content: [
      {
        type: "text",
        text: `Found ${replays.length} replays:\n` +
          replays.map((r: any) => 
            `- ${r.id} - ${r.user?.email || 'anonymous'} - ${r.started_at} - ${r.duration}s`
          ).join('\n'),
      },
    ],
  };
}

src/index.ts:629-651 (schema)

Tool definition including name, description, and input schema for parameters: project (string), limit (number, default 50), query (string). No required fields.

{
  name: "sentry_list_organization_replays",
  description: "List replays from a Sentry organization. Monitor user sessions, interactions, errors and experience issues.",
  inputSchema: {
    type: "object",
    properties: {
      project: {
        type: "string",
        description: "Project ID or slug",
      },
      limit: {
        type: "number",
        description: "Number of replays to return",
        default: 50,
      },
      query: {
        type: "string",
        description: "Search query",
      },
    },
    required: [],
  },
},

src/index.ts:93-691 (registration)

Tool registration in the ListToolsRequestSchema handler's tools array.

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "sentry_capture_exception",
        description: "Capture and send an exception to Sentry",
        inputSchema: {
          type: "object",
          properties: {
            error: {
              type: "string",
              description: "Error message or description",
            },
            level: {
              type: "string",
              enum: ["fatal", "error", "warning", "info", "debug"],
              description: "Severity level of the error",
              default: "error",
            },
            tags: {
              type: "object",
              description: "Key-value pairs to tag the error",
              additionalProperties: { type: "string" },
            },
            context: {
              type: "object",
              description: "Additional context data",
              additionalProperties: true,
            },
            user: {
              type: "object",
              description: "User information",
              properties: {
                id: { type: "string" },
                email: { type: "string" },
                username: { type: "string" },
              },
            },
          },
          required: ["error"],
        },
      },
      {
        name: "sentry_capture_message",
        description: "Capture and send a message to Sentry",
        inputSchema: {
          type: "object",
          properties: {
            message: {
              type: "string",
              description: "Message to send to Sentry",
            },
            level: {
              type: "string",
              enum: ["fatal", "error", "warning", "info", "debug"],
              description: "Severity level of the message",
              default: "info",
            },
            tags: {
              type: "object",
              description: "Key-value pairs to tag the message",
              additionalProperties: { type: "string" },
            },
            context: {
              type: "object",
              description: "Additional context data",
              additionalProperties: true,
            },
          },
          required: ["message"],
        },
      },
      {
        name: "sentry_add_breadcrumb",
        description: "Add a breadcrumb for debugging context",
        inputSchema: {
          type: "object",
          properties: {
            message: {
              type: "string",
              description: "Breadcrumb message",
            },
            category: {
              type: "string",
              description: "Category of the breadcrumb",
            },
            level: {
              type: "string",
              enum: ["fatal", "error", "warning", "info", "debug"],
              description: "Severity level",
              default: "info",
            },
            data: {
              type: "object",
              description: "Additional data for the breadcrumb",
              additionalProperties: true,
            },
          },
          required: ["message"],
        },
      },
      {
        name: "sentry_set_user",
        description: "Set user context for Sentry",
        inputSchema: {
          type: "object",
          properties: {
            id: {
              type: "string",
              description: "User ID",
            },
            email: {
              type: "string",
              description: "User email",
            },
            username: {
              type: "string",
              description: "Username",
            },
            ip_address: {
              type: "string",
              description: "User IP address",
            },
            segment: {
              type: "string",
              description: "User segment",
            },
          },
        },
      },
      {
        name: "sentry_set_tag",
        description: "Set a tag that will be sent with all events",
        inputSchema: {
          type: "object",
          properties: {
            key: {
              type: "string",
              description: "Tag key",
            },
            value: {
              type: "string",
              description: "Tag value",
            },
          },
          required: ["key", "value"],
        },
      },
      {
        name: "sentry_set_context",
        description: "Set custom context data",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Context name",
            },
            context: {
              type: "object",
              description: "Context data",
              additionalProperties: true,
            },
          },
          required: ["name", "context"],
        },
      },
      {
        name: "sentry_start_transaction",
        description: "Start a performance monitoring transaction",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Transaction name",
            },
            op: {
              type: "string",
              description: "Operation type (e.g., 'http.request', 'db.query')",
            },
            description: {
              type: "string",
              description: "Transaction description",
            },
          },
          required: ["name", "op"],
        },
      },
      {
        name: "sentry_finish_transaction",
        description: "Finish the current transaction",
        inputSchema: {
          type: "object",
          properties: {
            status: {
              type: "string",
              description: "Transaction status",
              enum: ["ok", "cancelled", "unknown", "invalid_argument", "deadline_exceeded", "not_found", "already_exists", "permission_denied", "resource_exhausted", "failed_precondition", "aborted", "out_of_range", "unimplemented", "internal_error", "unavailable", "data_loss", "unauthenticated"],
              default: "ok",
            },
          },
        },
      },
      {
        name: "sentry_start_session",
        description: "Start a new session for release health monitoring",
        inputSchema: {
          type: "object",
          properties: {
            distinctId: {
              type: "string",
              description: "Unique user identifier (ID, email, or username)",
            },
            sessionId: {
              type: "string",
              description: "Optional custom session ID",
            },
            release: {
              type: "string",
              description: "Release version",
            },
            environment: {
              type: "string",
              description: "Environment name (production, staging, etc)",
            },
          },
        },
      },
      {
        name: "sentry_end_session",
        description: "End the current session with a specific status",
        inputSchema: {
          type: "object",
          properties: {
            status: {
              type: "string",
              enum: ["exited", "crashed", "abnormal", "errored"],
              description: "How the session ended",
              default: "exited",
            },
          },
        },
      },
      {
        name: "sentry_set_release",
        description: "Set the release version for release health tracking",
        inputSchema: {
          type: "object",
          properties: {
            release: {
              type: "string",
              description: "Release version (e.g., 'myapp@1.0.0')",
            },
            dist: {
              type: "string",
              description: "Distribution identifier",
            },
          },
          required: ["release"],
        },
      },
      {
        name: "sentry_capture_session",
        description: "Manually capture a session for server-mode/request-mode",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "Unique session identifier",
            },
            distinctId: {
              type: "string",
              description: "User identifier",
            },
            status: {
              type: "string",
              enum: ["ok", "exited", "crashed", "abnormal", "errored"],
              description: "Session status",
              default: "ok",
            },
            duration: {
              type: "number",
              description: "Session duration in seconds",
            },
            errors: {
              type: "number",
              description: "Number of errors in session",
              default: 0,
            },
          },
          required: ["sessionId"],
        },
      },
      // API Management Tools
      {
        name: "sentry_list_projects",
        description: "List all projects in the organization",
        inputSchema: {
          type: "object",
          properties: {},
        },
      },
      {
        name: "sentry_list_issues",
        description: "List issues for a project",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            query: {
              type: "string",
              description: "Search query (e.g., 'is:unresolved', 'level:error')",
            },
          },
          required: ["projectSlug"],
        },
      },
      {
        name: "sentry_create_release",
        description: "Create a new release",
        inputSchema: {
          type: "object",
          properties: {
            version: {
              type: "string",
              description: "Release version (e.g., 'myapp@1.0.0')",
            },
            projects: {
              type: "array",
              items: { type: "string" },
              description: "List of project slugs",
            },
            url: {
              type: "string",
              description: "Release URL",
            },
            dateReleased: {
              type: "string",
              description: "Release date (ISO format)",
            },
          },
          required: ["version"],
        },
      },
      {
        name: "sentry_list_releases",
        description: "List releases for a project",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
          },
          required: ["projectSlug"],
        },
      },
      {
        name: "sentry_get_organization_stats",
        description: "Get organization statistics",
        inputSchema: {
          type: "object",
          properties: {
            stat: {
              type: "string",
              enum: ["received", "rejected", "blacklisted"],
              description: "Type of statistic",
            },
            since: {
              type: "string",
              description: "Start date (ISO format or timestamp)",
            },
            until: {
              type: "string",
              description: "End date (ISO format or timestamp)",
            },
            resolution: {
              type: "string",
              enum: ["10s", "1h", "1d"],
              description: "Time resolution",
            },
          },
          required: ["stat"],
        },
      },
      {
        name: "sentry_create_alert_rule",
        description: "Create an alert rule for a project",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            name: {
              type: "string",
              description: "Alert rule name",
            },
            conditions: {
              type: "array",
              description: "Alert conditions",
            },
            actions: {
              type: "array",
              description: "Alert actions",
            },
            frequency: {
              type: "number",
              description: "Check frequency in minutes",
              default: 30,
            },
          },
          required: ["projectSlug", "name"],
        },
      },
      {
        name: "sentry_resolve_short_id",
        description: "Retrieve details about an issue using its short ID. Maps short IDs to issue details, project context and status.",
        inputSchema: {
          type: "object",
          properties: {
            shortId: {
              type: "string",
              description: "The short ID of the issue (e.g., 'PROJ-123')",
            },
          },
          required: ["shortId"],
        },
      },
      {
        name: "sentry_get_event",
        description: "Retrieve a specific Sentry event from an issue. Requires issue ID/URL and event ID.",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            eventId: {
              type: "string",
              description: "Event ID",
            },
          },
          required: ["projectSlug", "eventId"],
        },
      },
      {
        name: "sentry_list_error_events_in_project",
        description: "List error events from a specific Sentry project. View recent errors, frequency patterns and occurrence timestamps.",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            limit: {
              type: "number",
              description: "Number of events to return",
              default: 50,
            },
            query: {
              type: "string",
              description: "Search query",
            },
          },
          required: ["projectSlug"],
        },
      },
      {
        name: "sentry_create_project",
        description: "Create a new project in Sentry. Track deployments, releases and health metrics.",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Project name",
            },
            slug: {
              type: "string",
              description: "Project slug (URL-friendly identifier)",
            },
            platform: {
              type: "string",
              description: "Platform (e.g., 'javascript', 'python', 'node')",
            },
            team: {
              type: "string",
              description: "Team slug",
            },
          },
          required: ["name", "slug", "team"],
        },
      },
      {
        name: "sentry_list_issue_events",
        description: "List events for a specific Sentry issue. Analyze event details, metadata and patterns.",
        inputSchema: {
          type: "object",
          properties: {
            issueId: {
              type: "string",
              description: "Issue ID",
            },
            limit: {
              type: "number",
              description: "Number of events to return",
              default: 50,
            },
          },
          required: ["issueId"],
        },
      },
      {
        name: "sentry_get_issue",
        description: "Retrieve and analyze a Sentry issue. Accepts issue URL or ID.",
        inputSchema: {
          type: "object",
          properties: {
            issueId: {
              type: "string",
              description: "Issue ID or URL",
            },
          },
          required: ["issueId"],
        },
      },
      {
        name: "sentry_list_organization_replays",
        description: "List replays from a Sentry organization. Monitor user sessions, interactions, errors and experience issues.",
        inputSchema: {
          type: "object",
          properties: {
            project: {
              type: "string",
              description: "Project ID or slug",
            },
            limit: {
              type: "number",
              description: "Number of replays to return",
              default: 50,
            },
            query: {
              type: "string",
              description: "Search query",
            },
          },
          required: [],
        },
      },
      {
        name: "sentry_setup_project",
        description: "Set up Sentry for a project returning a DSN and instructions for setup.",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            platform: {
              type: "string",
              description: "Platform for installation instructions",
              default: "javascript",
            },
          },
          required: ["projectSlug"],
        },
      },
      {
        name: "sentry_search_errors_in_file",
        description: "Search for Sentry errors occurring in a specific file. Find all issues related to a particular file path or filename.",
        inputSchema: {
          type: "object",
          properties: {
            projectSlug: {
              type: "string",
              description: "Project slug/identifier",
            },
            filename: {
              type: "string",
              description: "File path or filename to search for",
            },
          },
          required: ["projectSlug", "filename"],
        },
      },
    ],
  };
});

src/sentry-api-client.ts:177-180 (helper)

SentryAPIClient helper method that makes authenticated GET request to the organization's replays endpoint with query parameters.

async listReplays(params?: any) {
  const queryParams = params ? '?' + new URLSearchParams(params).toString() : '';
  return this.request(`/organizations/${this.org}/replays/${queryParams}`);
}

MCP Sentry para Cursor