# Better stack

```json
{
  "name": "Better stack",
  "slug": "better_stack",
  "url": "https://composio.dev/toolkits/better_stack",
  "markdown_url": "https://composio.dev/toolkits/better_stack.md",
  "logo_url": "https://logos.composio.dev/api/better_stack",
  "categories": [
    "developer tools & devops"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-05-12T10:02:56.159Z"
}
```

![Better stack logo](https://logos.composio.dev/api/better_stack)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Better stack MCP or direct API to monitor incidents, send alerts, analyze logs, and manage on-call schedules through natural language.

## Summary

Better Stack is a monitoring, logging, and incident management solution for apps and services. It helps teams ensure application reliability and performance with real-time insights.

## Categories

- developer tools & devops

## Toolkit Details

- Tools: 117

## Images

- Logo: https://logos.composio.dev/api/better_stack

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Better Stack.
  - Setup:
    - Configure Api Key credentials for Better Stack.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Show uptime percentage for API monitor
- Create escalation policy for on-call team
- List heartbeat availability for last week
- Delete unused source group from logging

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `BETTER_STACK_ACKNOWLEDGE_INCIDENT` | Acknowledge Incident | Tool to acknowledge an ongoing incident. Use when you need to mark an incident as being worked on, which prevents further escalations. Acknowledging an incident signals that someone is actively addressing the issue. |
| `BETTER_STACK_CREATE_ESCALATION_POLICY` | Create Escalation Policy | Creates a new escalation policy for incident management. Escalation policies define who gets notified and in what order when incidents occur. Supports multiple step types: 'escalation' (notify members), 'instructions' (guidance text), 'time_branching' (route by schedule), and 'metadata_branching' (route by incident metadata). For escalation steps, a valid urgency_id from the Severities API is required. |
| `BETTER_STACK_CREATE_HEARTBEAT` | Create Heartbeat | Tool to create a new heartbeat monitor for cron jobs and scheduled tasks. Use when you need to set up monitoring for a service that should send regular heartbeat signals. |
| `BETTER_STACK_CREATE_HEARTBEAT_GROUP` | Create Heartbeat Group | Tool to create a new heartbeat group. Use when you need to organize related heartbeat checks under a single, logical group. Example prompt: "Create a new heartbeat group named 'Backend services'." |
| `BETTER_STACK_CREATE_INCIDENT` | Create Incident | Tool to create a new incident and alert the on-call person. Use when you need to manually report an incident or trigger escalation workflows. The incident will be routed according to the specified escalation policy or default team settings. |
| `BETTER_STACK_CREATE_INCIDENT_COMMENT` | Create Incident Comment | Tool to create a new comment on an incident. Use when you need to add documentation, updates, or notes to an existing incident in Better Stack. |
| `BETTER_STACK_CREATE_METADATA` | Create Metadata | Tool to create or update a metadata record for a resource. Metadata provides key-value associations for resources like monitors, heartbeats, or incidents. Use when you need to tag or annotate resources with custom data. Existing values for the specified key will be completely replaced. |
| `BETTER_STACK_CREATE_MONITOR` | Create Monitor | Tool to create a new uptime monitor for a URL or service. Use when you need to set up monitoring for websites, APIs, servers, or network services. Supports multiple monitor types including HTTP/HTTPS status checks, keyword monitoring, ping, TCP/UDP, email protocols, DNS queries, and browser automation with Playwright. |
| `BETTER_STACK_CREATE_MONITOR_GROUP` | Create Monitor Group | Tool to create a new monitor group. Use when you need to organize related monitors under a single, logical group for better dashboard organization. |
| `BETTER_STACK_CREATE_ON_CALL_SCHEDULE` | Create On-Call Schedule | Tool to create a new on-call schedule. Use when you need to set up a new on-call calendar for managing team rotations. |
| `BETTER_STACK_CREATE_OUTGOING_WEBHOOK` | Create Outgoing Webhook Integration | Tool to create a new outgoing webhook integration. Use when you need to register an endpoint to receive event notifications from Better Stack. |
| `BETTER_STACK_CREATE_POLICY_GROUP` | Create Escalation Policy Group | Tool to create a new escalation policy group. Use when you need to organize related escalation policies under a single logical group. |
| `BETTER_STACK_CREATE_SOURCE_GROUP` | Create Source Group | Tool to create a new source group. Use when you have finalized the group name (and optional sort index) and need to organize related log sources under that group. |
| `BETTER_STACK_CREATE_STATUS_PAGE_GROUP` | Create Status Page Group | Tool to create a new status page group. Use when you need to organize related status pages under a single logical group with a descriptive name. |
| `BETTER_STACK_CREATE_STATUS_PAGE_REPORT` | Create Status Page Report | Tool to create a new status page report (incident or maintenance). Use when you need to publish a status update about an ongoing incident or scheduled maintenance on a status page. |
| `BETTER_STACK_CREATE_STATUS_PAGE_RESOURCE` | Create Status Page Resource | Tool to create a new status page resource. Use when you need to add a monitor, heartbeat, or other resource to a status page for public visibility tracking. |
| `BETTER_STACK_CREATE_STATUS_PAGE_SECTION` | Create Status Page Section | Tool to create a new section on a status page. Use when organizing resources into logical groups (e.g., by datacenter or service type). Leave name blank to hide the section header. |
| `BETTER_STACK_CREATE_STATUS_UPDATE` | Create Status Update | Tool to create a new status update for an existing status report. Use when you need to post an update about the current state of an incident or maintenance. The update can include a message, affected resources with their status, and optionally notify subscribers. |
| `BETTER_STACK_CREATE_URGENCIES` | Create Severity Level | Tool to create a new severity level (urgency) for incident management. Use when you need to define notification preferences for different incident severity levels. |
| `BETTER_STACK_CREATE_URGENCY_GROUP` | Create Urgency Group | Tool to create a new urgency group (severity group) for incident categorization. Use when you need to define severity levels for monitoring alerts and incidents. |
| `BETTER_STACK_DELETE_ESCALATION_POLICY` | Delete Escalation Policy | Tool to delete an escalation policy by ID. Use when you need to permanently remove an existing escalation policy after confirming its ID. |
| `BETTER_STACK_DELETE_HEARTBEAT` | Delete Heartbeat | Tool to permanently delete a heartbeat by ID. Use when you need to remove a heartbeat that is no longer needed. |
| `BETTER_STACK_DELETE_HEARTBEAT_GROUP` | Delete Heartbeat Group | Tool to permanently delete a heartbeat group by ID. Use when you need to remove a heartbeat group that is no longer needed. |
| `BETTER_STACK_DELETE_INCIDENT` | Delete Incident | Tool to permanently delete an existing incident by ID. Use when you need to remove an incident from Better Stack Uptime. |
| `BETTER_STACK_DELETE_INCIDENT_COMMENT` | Delete Incident Comment | Tool to delete an existing comment from an incident. Use when you need to remove a comment that was previously added via the API. Note: Only comments created via the API can be deleted; comments created in the UI cannot be deleted via the API. |
| `BETTER_STACK_DELETE_MONITOR` | Delete Monitor | Tool to permanently delete a monitor by ID from Better Stack Uptime. Use when you need to remove a monitor that is no longer needed. |
| `BETTER_STACK_DELETE_MONITOR_GROUP` | Delete Monitor Group | Tool to permanently delete a monitor group by ID from Better Stack Uptime. Use when you need to remove a monitor group that is no longer needed. |
| `BETTER_STACK_DELETE_ON_CALL_SCHEDULE` | Delete On-Call Schedule | Tool to permanently delete an on-call schedule by ID. Use when you need to remove an on-call calendar that is no longer needed. |
| `BETTER_STACK_DELETE_OUTGOING_WEBHOOK` | Delete Outgoing Webhook Integration | Tool to delete an outgoing webhook integration by ID. Use when you need to permanently remove an existing webhook integration. |
| `BETTER_STACK_DELETE_POLICY_GROUP` | Delete Escalation Policy Group | Tool to delete an escalation policy group by ID. Use when you need to permanently remove an existing escalation policy group after confirming its ID. |
| `BETTER_STACK_DELETE_SOURCE_GROUP` | Delete Source Group | Tool to permanently delete a source group by ID from Better Stack Telemetry (Logs). Source groups are used to organize related log sources. Use this action when you need to remove a source group that is no longer needed. Note: This action requires a Telemetry API token (not an Uptime API token). Deleting a source group does not delete the sources within it - they will become ungrouped. |
| `BETTER_STACK_DELETE_STATUS_PAGE_GROUP` | Delete Status Page Group | Tool to delete a status page group by ID. Use when you need to permanently remove an existing status page group. |
| `BETTER_STACK_DELETE_STATUS_PAGE_REPORT` | Delete Status Page Report | Tool to permanently delete a status page report by ID from Better Stack Uptime. Use this action when you need to remove an existing status page report that is no longer needed. The report will be permanently deleted and cannot be recovered. |
| `BETTER_STACK_DELETE_STATUS_PAGE_RESOURCE` | Delete Status Page Resource | Tool to delete an existing resource from a status page. Use when you need to permanently remove a resource (monitor or heartbeat) that is displayed on a status page. |
| `BETTER_STACK_DELETE_STATUS_PAGE_SECTION` | Delete Status Page Section | Tool to permanently delete a status page section by ID. Use when you need to remove a section from a status page that is no longer needed. Sections organize resources on status pages for better visibility. |
| `BETTER_STACK_DELETE_STATUS_PAGE_STATUS_REPORT_STATUS_UPDATE` | Delete Status Update | Tool to delete an existing status update from a status report. Use when you need to permanently remove a status update after confirming its ID. |
| `BETTER_STACK_DELETE_URGENCY` | Delete Severity | Tool to delete a severity (urgency) by ID. Use when you need to permanently remove an existing severity level after confirming its ID. |
| `BETTER_STACK_DELETE_URGENCY_GROUP` | Delete Urgency Group | Tool to permanently delete an urgency group (severity group) by ID. Use when you need to remove an existing severity group that is no longer needed. |
| `BETTER_STACK_ESCALATE_INCIDENT` | Escalate Incident | Tool to escalate an ongoing incident to a user, team, schedule, policy, or organization. Use when you need to route an active incident to the appropriate responders with specified notification channels (call, SMS, email, push). |
| `BETTER_STACK_GET_ESCALATION_POLICY` | Get Escalation Policy | Tool to get a single escalation policy by its ID. Use when you need full details of a specific escalation policy including its steps, repeat settings, and team information. |
| `BETTER_STACK_GET_HEARTBEAT` | Get Heartbeat | Tool to get a single heartbeat by ID. Use when you need to fetch details of a specific heartbeat. |
| `BETTER_STACK_GET_HEARTBEAT_AVAILABILITY` | Get Heartbeat Availability | Tool to retrieve availability summary for a specific heartbeat. Use when you need availability metrics for a heartbeat within an optional date range. |
| `BETTER_STACK_GET_HEARTBEAT_GROUP` | Get Heartbeat Group | Tool to get a single heartbeat group by ID. Use when you need to fetch details of a specific heartbeat group. |
| `BETTER_STACK_GET_INCIDENT_COMMENT` | Get Incident Comment | Tool to get a single comment from an incident. Use when you need to retrieve details of a specific comment on a Better Stack incident. |
| `BETTER_STACK_GET_MONITOR` | Get Monitor | Tool to get a single monitor. Use when you need full details of a specific monitor by its ID. |
| `BETTER_STACK_GET_MONITOR_AVAILABILITY` | Get Monitor Availability | Tool to return an availability summary for a specific monitor. Use when you need uptime percentage and incident details within an optional date range. |
| `BETTER_STACK_GET_MONITOR_GROUPS` | Get Monitor Group | Tool to get a single monitor group by ID. Use when you need to fetch details of a specific monitor group. |
| `BETTER_STACK_GET_MONITOR_GROUPS_MONITORS` | Get Monitor Group's Monitors | Tool to get all monitors belonging to a monitor group. Use when you need to retrieve all monitors within a specific monitor group, with optional pagination support. |
| `BETTER_STACK_GET_MONITOR_RESPONSE_TIMES` | Get Monitor Response Times | Retrieves response time performance metrics for a specific uptime monitor. Returns detailed timing data (DNS lookup, connection, TLS handshake, data transfer) grouped by geographic region. By default returns data for the last 24 hours. Use this to analyze monitor performance, identify latency issues, or compare response times across regions. Requires a valid monitor_id which can be obtained from the list_monitors action. |
| `BETTER_STACK_GET_ON_CALL_SCHEDULE` | Get On-Call Schedule | Tool to get a single on-call schedule by ID. Use when you need to retrieve who is currently on-call for a specific schedule. Optionally specify a date to check on-call status at a specific time. |
| `BETTER_STACK_GET_OUTGOING_WEBHOOK` | Get Outgoing Webhook Integration | Tool to get a single outgoing webhook integration by ID. Use when you need to retrieve details of a specific webhook integration. |
| `BETTER_STACK_GET_POLICY_GROUP` | Get Escalation Policy Group | Tool to get a single escalation policy group. Use when you need full details of a specific escalation policy group by its ID. |
| `BETTER_STACK_GET_STATUS_PAGE` | Get Status Page | Tool to get a single status page by ID. Use when you need detailed information about a specific status page. |
| `BETTER_STACK_GET_STATUS_PAGE_GROUP` | Get Status Page Group | Tool to get a single status page group by ID. Use when you need to retrieve details of a specific status page group. |
| `BETTER_STACK_GET_STATUS_PAGE_REPORT` | Get Status Page Report | Tool to get a single status page report by ID. Use when you need detailed information about a specific status report or incident. |
| `BETTER_STACK_GET_STATUS_PAGE_RESOURCE` | Get Status Page Resource | Tool to get a single status page resource by ID. Use when you need detailed information about a specific resource on a status page. |
| `BETTER_STACK_GET_STATUS_PAGE_SECTION` | Get Status Page Section | Tool to get a single status page section. Use when you need details of a specific section within a status page by its ID. |
| `BETTER_STACK_GET_STATUS_UPDATE` | Get Status Update | Tool to get a single status update by its ID. Use when you need details of a specific status update for a status report on your status page. |
| `BETTER_STACK_GET_UPTIME_API_TOKEN` | Get Uptime API Token | Tool to retrieve the configured Uptime API token. Use when you need the Uptime API token for subsequent authenticated API calls. |
| `BETTER_STACK_GET_URGENCY` | Get Severity Level | Tool to get a single severity level (urgency) by ID. Use when you need to fetch details of a specific urgency configuration. |
| `BETTER_STACK_GET_URGENCY_GROUP` | Get Urgency Group | Tool to get a single urgency group (severity group) by ID. Use when you need to fetch details of a specific urgency group. |
| `BETTER_STACK_LIST_AWS_CLOUDWATCH_INTEGRATIONS` | List AWS CloudWatch Integrations | Tool to list all AWS CloudWatch integrations. Use when you need to retrieve and inspect all configured AWS CloudWatch on-call integrations. |
| `BETTER_STACK_LIST_AZURE_INTEGRATIONS` | List Azure Integrations | Tool to list all Azure integrations. Use when you need to retrieve and inspect all configured Azure on-call integrations. |
| `BETTER_STACK_LIST_CATALOG_RELATIONS` | List Catalog Relations | Tool to list all catalog relations. Use when you need to retrieve all catalog relations, supports pagination. |
| `BETTER_STACK_LIST_DATADOG_INTEGRATIONS` | List Datadog Integrations | Tool to list all Datadog integrations. Use when you need to retrieve and inspect all configured Datadog on-call integrations. |
| `BETTER_STACK_LIST_ELASTIC_INTEGRATIONS` | List Elastic Integrations | Tool to list Elastic integrations. Use when you need to retrieve and inspect all configured Elastic integrations. |
| `BETTER_STACK_LIST_EMAIL_INTEGRATIONS` | List Email Integrations | Tool to list email integrations. Use when you need to retrieve and inspect all configured email integrations with optional team filtering and pagination support. |
| `BETTER_STACK_LIST_GOOGLE_MONITORING_INTEGRATIONS` | List Google Monitoring Integrations | Tool to list all Google Monitoring integrations. Use when you need to view your configured Google Monitoring on-call integrations with pagination support. |
| `BETTER_STACK_LIST_GRAFANA_INTEGRATIONS` | List Grafana Integrations | Tool to list all Grafana integrations. Use when you need to retrieve and inspect all configured Grafana integrations. |
| `BETTER_STACK_LIST_HEARTBEAT_GROUPS` | List Heartbeat Groups | Tool to list all heartbeat groups. Use when you need to retrieve configured heartbeat groups with optional filtering by team name. |
| `BETTER_STACK_LIST_HEARTBEATS` | List Heartbeats | Tool to list all heartbeats. Use when you need to retrieve your configured uptime heartbeats with optional pagination. |
| `BETTER_STACK_LIST_INCIDENTS_COMMENTS` | List Incidents Comments | Tool to list all comments on an incident. Use when you need to retrieve all comments associated with a Better Stack incident. |
| `BETTER_STACK_LIST_INCIDENTS_TIMELINE` | List Incidents Timeline | Tool to retrieve all timeline events for an incident. Use when you need to get a chronological history of events, comments, responses, and changes for a specific incident in Better Stack. Returns all timeline items without pagination. |
| `BETTER_STACK_LIST_INCIDENTS_UPTIME` | List Incidents Uptime | Tool to list all incidents with optional filtering by monitor, heartbeat, date range, or resolution status. Supports pagination with default of 10 per page and maximum of 50. |
| `BETTER_STACK_LIST_JIRA_INTEGRATIONS` | List Jira Integrations | Tool to list all Jira integrations. Use when you need to retrieve and inspect all configured Jira integrations. |
| `BETTER_STACK_LIST_METADATA` | List Metadata | Tool to list all existing metadata. Use when you need to retrieve metadata records with optional filtering by team, owner resource ID, or owner resource type. |
| `BETTER_STACK_LIST_MONITOR_GROUPS` | List Monitor Groups | Tool to list all monitor groups. Use when you need to retrieve existing monitor groups with optional team filtering and pagination support. |
| `BETTER_STACK_LIST_MONITORS` | List Monitors | Tool to list all monitors. Use when you need to retrieve existing uptime monitors with optional filtering by URL or name and pagination. |
| `BETTER_STACK_LIST_NEW_RELIC_INTEGRATIONS` | List New Relic Integrations | Tool to list New Relic integrations. Use when you need to retrieve and inspect all configured New Relic integrations with pagination support. |
| `BETTER_STACK_LIST_ON_CALL_EVENTS` | List On-Call Schedule Events | Tool to list all events for a specific on-call schedule. Use when you need to retrieve the calendar of scheduled on-call periods for a team. |
| `BETTER_STACK_LIST_ON_CALL_SCHEDULES` | List On-Call Schedules | Tool to list all on-call schedules. Use when you need to retrieve all configured on-call calendars. |
| `BETTER_STACK_LIST_OUTGOING_WEBHOOKS` | List Outgoing Webhook Integrations | Tool to list all outgoing webhook integrations. Use when you need to retrieve configured webhook endpoints for event notifications. |
| `BETTER_STACK_LIST_PAGER_DUTY_WEBHOOKS` | List PagerDuty Webhooks | Tool to list PagerDuty integrations. Use when you need to retrieve and inspect all configured PagerDuty integrations. |
| `BETTER_STACK_LIST_POLICIES` | List Escalation Policies | Tool to list all escalation policies. Use when you need to retrieve existing escalation policies with optional filtering by team name. |
| `BETTER_STACK_LIST_POLICY_GROUPS` | List Escalation Policy Groups | Tool to list all escalation policy groups. Use when you need to retrieve existing policy groups with optional team filtering and pagination support. |
| `BETTER_STACK_LIST_PROMETHEUS_INTEGRATIONS` | List Prometheus Integrations | Tool to list all Prometheus integrations. Use when you need to retrieve and inspect all configured Prometheus on-call integrations. |
| `BETTER_STACK_LIST_SINGLE_INCIDENT` | List Single Incident | Tool to retrieve detailed information about a single incident by its ID. Use when you need to get the full details of a specific incident including its status, timeline, affected regions, and notification settings. |
| `BETTER_STACK_LIST_SLACK_INTEGRATIONS` | List Slack Integrations | Tool to list all Slack integrations. Use when you need to retrieve and inspect all configured Slack channel integrations. |
| `BETTER_STACK_LIST_SPLUNK_ON_CALL_INTEGRATIONS` | List Splunk On-Call Integrations | Tool to list all Splunk On-Call integrations. Use when you need to retrieve and inspect all configured Splunk On-Call on-call integrations. |
| `BETTER_STACK_LIST_STATUS_PAGE_GROUPS` | List Status Page Groups | Tool to list all status page groups. Use when you need to retrieve existing status page groups with optional pagination. |
| `BETTER_STACK_LIST_STATUS_PAGE_GROUPS_STATUS_PAGES` | List Status Pages In Status Page Group | Tool to list status pages within a specific status page group. Use when you need to retrieve all status pages belonging to a particular group with optional pagination. |
| `BETTER_STACK_LIST_STATUS_PAGE_REPORTS` | List Status Page Reports | Tool to list all reports on a status page. Use when you need to retrieve existing status page reports with optional pagination via `page` and `per_page`. |
| `BETTER_STACK_LIST_STATUS_PAGE_REPORT_STATUS_UPDATES` | List Status Page Report Status Updates | Tool to list all status updates for a status page report. Use when you need to retrieve updates posted on a specific status page report with optional pagination. |
| `BETTER_STACK_LIST_STATUS_PAGES` | List Status Pages | Tool to list all your status pages. Use when you need to retrieve existing status pages with optional pagination. |
| `BETTER_STACK_LIST_STATUS_PAGE_SECTIONS` | List Status Page Sections | Tool to list all sections of a specific status page. Use when you need to retrieve the existing sections within a status page. |
| `BETTER_STACK_LIST_STATUS_PAGES_RESOURCES` | List Status Page Resources | Tool to list all resources on a status page. Use when you need to retrieve existing resources with optional pagination. |
| `BETTER_STACK_LIST_URGENCIES` | List Severity Levels | Tool to list all severity levels (urgencies). Use when you need to retrieve existing incident severity configurations with their notification settings. |
| `BETTER_STACK_LIST_URGENCY_GROUPS` | List Urgency Groups | Tool to list all urgency groups (severity groups). Use when you need to retrieve existing urgency groups with optional team filtering and pagination support. |
| `BETTER_STACK_RESOLVE_INCIDENT` | Resolve Incident | Tool to resolve an ongoing incident. Use when you need to mark an incident as resolved and close it. Resolving an incident signals that the issue has been fixed and stops any further escalations. |
| `BETTER_STACK_UPDATE_ESCALATION_POLICY` | Update Escalation Policy | Tool to update an existing escalation policy. Use when you need to modify policy attributes like name, repeat settings, or escalation steps. Only the fields you provide will be updated (partial updates supported). |
| `BETTER_STACK_UPDATE_HEARTBEAT` | Update Heartbeat | Tool to update an existing heartbeat configuration. Use after retrieving a heartbeat and choosing which fields to change. |
| `BETTER_STACK_UPDATE_HEARTBEAT_GROUP` | Update Heartbeat Group | Updates an existing heartbeat group's properties. Use to rename a group, change its display order, or pause/resume monitoring for all heartbeats in the group. |
| `BETTER_STACK_UPDATE_INCIDENT_COMMENT` | Update Incident Comment | Tool to update an existing comment on an incident. Use when you need to modify the content of a comment that was previously added to a Better Stack incident. |
| `BETTER_STACK_UPDATE_MONITOR` | Update Monitor | Tool to update an existing uptime monitor configuration. Use when you need to modify settings of an existing monitor such as check frequency, notification preferences, URLs, or monitoring behavior. |
| `BETTER_STACK_UPDATE_MONITOR_GROUP` | Update Monitor Group | Updates an existing monitor group's properties. Use to rename a group, change its display order, or pause/resume monitoring for all monitors in the group. |
| `BETTER_STACK_UPDATE_ON_CALL_SCHEDULE` | Update On-Call Schedule | Tool to update an on-call schedule's name. Use when you need to rename an existing on-call calendar. |
| `BETTER_STACK_UPDATE_OUTGOING_WEBHOOK` | Update Outgoing Webhook Integration | Tool to update an existing outgoing webhook integration. Use when you need to modify the configuration of a webhook endpoint. |
| `BETTER_STACK_UPDATE_POLICY_GROUP` | Update Escalation Policy Group | Updates an existing escalation policy group's properties. Use to rename a group or change its display order. |
| `BETTER_STACK_UPDATE_SOURCE_GROUP` | Update Source Group | Update an existing source group in Better Stack Logs/Telemetry. Use this to rename a source group or change its sort order. Requires a Telemetry API token (different from Uptime API token). |
| `BETTER_STACK_UPDATE_STATUS_PAGE_GROUP` | Update Status Page Group | Tool to update an existing status page group. Use when you need to modify the name or display order of a status page group. |
| `BETTER_STACK_UPDATE_STATUS_PAGE_REPORT` | Update Status Page Report | Tool to update an existing status page report. Use when you need to modify the title, timing, or affected resources of an existing incident or maintenance report. |
| `BETTER_STACK_UPDATE_STATUS_PAGE_RESOURCE` | Update Status Page Resource | Tool to update an existing status page resource. Use when you need to modify the display name, position, widget type, or other properties of a resource on a status page. |
| `BETTER_STACK_UPDATE_STATUS_PAGES` | Update Status Pages | Tool to update an existing status page configuration. Use when modifying settings like company info, appearance, access control, or display preferences. |
| `BETTER_STACK_UPDATE_STATUS_PAGE_SECTION` | Update Status Page Section | Tool to update an existing status page section. Use when reorganizing sections or changing their display. Leave name blank to hide the section header. |
| `BETTER_STACK_UPDATE_STATUS_PAGE_STATUS_REPORT_STATUS_UPDATE` | Update Status Update | Tool to update an existing status update for a status report. Use when you need to modify the message, affected resources, or other details of a previously created status update. |
| `BETTER_STACK_UPDATE_URGENCIES` | Update Severity Level | Tool to update an existing severity level (urgency) configuration. Use when you need to modify notification settings or name for a specific severity level. |
| `BETTER_STACK_UPDATE_URGENCY_GROUP` | Update Urgency Group | Tool to update an existing urgency group (severity group). Use when you need to modify the name or sort order of a severity group. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Better stack Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Better stack actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'Show me the latest uptime reports for all backend monitors.'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'Show me the latest uptime reports for all backend monitors.'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and Claude Agent SDK
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Create Tool Router Session

Initialize the Composio client and create a Tool Router session
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });

console.log("Creating Tool Router session...");
const { mcp } = await composio.create('your-user-id');
console.log(`Tool Router session created: ${mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Better stack tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('Get monitor availability for monitor ID 12345 from the past week')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText, stepCountIs } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: mcp.url,
    headers: { 'x-api-key': 'your-composio-api-key' }
  }
});

const tools = await client.tools();

const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{ role: 'user', content: 'Get monitor availability for monitor ID 12345 from the past week' }],
  stopWhen: stepCountIs( 5 )
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Better stack Integration

- Supports both Better stack MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for reading, writing, and querying your Better stack data

### 2. Managed Auth

- Built-in API Key handling with secure storage and rotation
- Central place to manage, scope, and revoke Better stack access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Better stack
- Scoped, least privilege access to Better stack resources
- Full audit trail of agent actions to support review and compliance

## Use Better stack with any AI Agent Framework

Choose a framework you want to connect Better stack with:

- [OpenAI Agents SDK](https://composio.dev/toolkits/better_stack/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/better_stack/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/better_stack/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/better_stack/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/better_stack/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/better_stack/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/better_stack/framework/hermes-agent)
- [Google ADK](https://composio.dev/toolkits/better_stack/framework/google-adk)
- [LangChain](https://composio.dev/toolkits/better_stack/framework/langchain)
- [Vercel AI SDK](https://composio.dev/toolkits/better_stack/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/better_stack/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/better_stack/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/better_stack/framework/crew-ai)
- [Pydantic AI](https://composio.dev/toolkits/better_stack/framework/pydantic-ai)
- [AutoGen](https://composio.dev/toolkits/better_stack/framework/autogen)

## Related Toolkits

- [Supabase](https://composio.dev/toolkits/supabase) - Supabase is an open-source backend platform offering scalable Postgres databases, authentication, storage, and real-time APIs. It lets developers build modern apps without managing infrastructure.
- [Codeinterpreter](https://composio.dev/toolkits/codeinterpreter) - Codeinterpreter is a Python-based coding environment with built-in data analysis and visualization. It lets you instantly run scripts, plot results, and prototype solutions inside supported platforms.
- [GitHub](https://composio.dev/toolkits/github) - GitHub is a code hosting platform for version control and collaborative software development. It streamlines project management, code review, and team workflows in one place.
- [Ably](https://composio.dev/toolkits/ably) - Ably is a real-time messaging platform for live chat and data sync in modern apps. It offers global scale and rock-solid reliability for seamless, instant experiences.
- [Abuselpdb](https://composio.dev/toolkits/abuselpdb) - Abuselpdb is a central database for reporting and checking IPs linked to malicious online activity. Use it to quickly identify and report suspicious or abusive IP addresses.
- [Alchemy](https://composio.dev/toolkits/alchemy) - Alchemy is a blockchain development platform offering APIs and tools for Ethereum apps. It simplifies building and scaling Web3 projects with robust infrastructure.
- [Algolia](https://composio.dev/toolkits/algolia) - Algolia is a hosted search API that powers lightning-fast, relevant search experiences for web and mobile apps. It helps developers deliver instant, typo-tolerant, and scalable search without complex infrastructure.
- [Anchor browser](https://composio.dev/toolkits/anchor_browser) - Anchor browser is a developer platform for AI-powered web automation. It transforms complex browser actions into easy API endpoints for streamlined web interaction.
- [Apiflash](https://composio.dev/toolkits/apiflash) - Apiflash is a website screenshot API for programmatically capturing web pages. It delivers high-quality screenshots on demand for automation, monitoring, or reporting.
- [Apiverve](https://composio.dev/toolkits/apiverve) - Apiverve delivers a suite of powerful APIs that simplify integration for developers. It's designed for reliability and scalability so you can build faster, smarter applications without the integration headache.
- [Appcircle](https://composio.dev/toolkits/appcircle) - Appcircle is an enterprise-grade mobile CI/CD platform for building, testing, and publishing mobile apps. It streamlines mobile DevOps so teams ship faster and with more confidence.
- [Appdrag](https://composio.dev/toolkits/appdrag) - Appdrag is a cloud platform for building websites, APIs, and databases with drag-and-drop tools and code editing. It accelerates development and iteration by combining hosting, database management, and low-code features in one place.
- [Appveyor](https://composio.dev/toolkits/appveyor) - AppVeyor is a cloud-based continuous integration service for building, testing, and deploying applications. It helps developers automate and streamline their software delivery pipelines.
- [Backendless](https://composio.dev/toolkits/backendless) - Backendless is a backend-as-a-service platform for mobile and web apps, offering database, file storage, user authentication, and APIs. It helps developers ship scalable applications faster without managing server infrastructure.
- [Baserow](https://composio.dev/toolkits/baserow) - Baserow is an open-source no-code database platform for building collaborative data apps. It makes it easy for teams to organize data and automate workflows without writing code.
- [Bench](https://composio.dev/toolkits/bench) - Bench is a benchmarking tool for automated performance measurement and analysis. It helps you quickly evaluate, compare, and track your systems or workflows.
- [Bitbucket](https://composio.dev/toolkits/bitbucket) - Bitbucket is a Git-based code hosting and collaboration platform for teams. It enables secure repository management and streamlined code reviews.
- [Blazemeter](https://composio.dev/toolkits/blazemeter) - Blazemeter is a continuous testing platform for web and mobile app performance. It empowers teams to automate and analyze large-scale tests with ease.
- [Blocknative](https://composio.dev/toolkits/blocknative) - Blocknative delivers real-time mempool monitoring and transaction management for public blockchains. Instantly track pending transactions and optimize blockchain interactions with live data.
- [Bolt iot](https://composio.dev/toolkits/bolt_iot) - Bolt IoT is a platform for building and managing IoT projects with cloud-based device control and monitoring. It makes connecting sensors and actuators to the internet seamless for automation and data insights.

## Frequently Asked Questions

### Do I need my own developer credentials to use Better stack with Composio?

Yes, Better stack requires you to configure your own API key credentials. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)