Skip to main content
Glama
metrovoc

bark-mcp-server

by metrovoc
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Remote

Bark MCP Server

A Model Context Protocol (MCP) server for sending iOS push notifications via Bark.

npm version License: MIT

Features

This MCP server provides tools for AI assistants to send push notifications to iOS devices through Bark. It supports all Bark API features including:

Core Tools

  1. send_bark_notification - Send a single push notification

  2. send_bark_batch_notifications - Send multiple notifications in batch

  3. check_bark_server_health - Check if a Bark server is healthy

Supported Bark Features

  • Basic notifications with title, subtitle, and body

  • URL redirection - Open links when notifications are tapped

  • Notification grouping - Organize notifications by group

  • Custom icons - Use custom notification icons (iOS 15+)

  • Sound customization - Use custom notification sounds

  • Call notifications - Play sound repeatedly for 30 seconds

  • Notification levels:

    • active (default)

    • timeSensitive - Displayed during focus mode

    • passive - Silent notification

    • critical - Overrides silent/do not disturb modes

  • Badge management - Set app icon badge numbers

  • Encryption support - Send encrypted notifications

Related MCP server: ntfy-mcp-server

Installation

Quick Start (Recommended)

npx @metrovoc/bark-mcp-server

Global Installation

npm install -g @metrovoc/bark-mcp-server
bark-mcp-server

Local Installation

npm install @metrovoc/bark-mcp-server
npx @metrovoc/bark-mcp-server

Environment Variables

For easier usage, set these environment variables:

  • BARK_KEY: Your Bark device key (required for automatic usage)

  • BARK_SERVER_URL: Bark server URL (optional, defaults to https://api.day.app)

Usage

With Claude Code

Recommended (with environment variables):

claude mcp add bark -e BARK_KEY=your-device-key -- npx -y @metrovoc/bark-mcp-server

Manual configuration:

{
  "bark": {
    "command": "npx",
    "args": ["-y", "@metrovoc/bark-mcp-server"],
    "env": {
      "BARK_KEY": "your-device-key",
      "BARK_SERVER_URL": "https://api.day.app"
    }
  }
}

For detailed Claude Code setup instructions, see CLAUDE.md.

With Claude Desktop

Add the server to your claude_desktop_config.json:

{
  "mcpServers": {
    "bark": {
      "command": "npx",
      "args": ["-y", "@metrovoc/bark-mcp-server"],
      "env": {
        "BARK_KEY": "your-device-key",
        "BARK_SERVER_URL": "https://api.day.app"
      }
    }
  }
}

Alternative Configuration Methods

Global Installation:

claude mcp add bark -e BARK_KEY=your-device-key -- bark-mcp-server

Direct Node.js:

claude mcp add bark -e BARK_KEY=your-device-key -- node /path/to/@metrovoc/bark-mcp-server/build/index.js

With MCP Inspector

For testing and debugging:

npx @modelcontextprotocol/inspector npx @metrovoc/bark-mcp-server

With environment variables:

BARK_KEY=your-device-key npx @modelcontextprotocol/inspector npx @metrovoc/bark-mcp-server

AI Collaboration Features

This MCP server is specifically designed to enable efficient human-AI collaboration. AI assistants like Claude Code can use these tools to:

  • 🚨 Alert you when errors require intervention

  • ✅ Notify when tasks are completed and ready for review

  • 🤔 Request decisions when user input is needed

  • 🧪 Summon you for testing and verification

  • 📊 Provide progress updates on long-running operations

The intelligent tool descriptions guide AI to choose appropriate notification priorities and timing, enabling you to focus on other work while AI handles routine tasks.

Tool Reference

send_bark_notification

Send a single push notification to an iOS device. AI assistants should use this to notify users when tasks complete, errors occur, or input is needed.

Parameters:

  • body (required) - Notification content/message

  • server_url (optional) - Bark server URL (defaults to BARK_SERVER_URL env var or https://api.day.app)

  • device_key (optional) - Device key (defaults to BARK_KEY env var)

  • title (optional) - Notification title

  • subtitle (optional) - Notification subtitle

  • url (optional) - URL to open when notification is tapped

  • group (optional) - Group name for organizing notifications

  • icon (optional) - Custom icon URL (iOS 15+)

  • sound (optional) - Custom notification sound name

  • call (optional) - Play sound repeatedly for 30 seconds (use for critical issues)

  • level (optional) - Priority level:

    • critical: Urgent issues requiring immediate attention (errors, failures)

    • timeSensitive: Important updates during focus mode (task completion, testing needed)

    • active: General notifications (progress updates)

    • passive: Low-priority background info

  • badge (optional) - Badge number on app icon

  • ciphertext (optional) - Encrypted message content

AI Usage Examples:

// Critical error requiring immediate attention
{
  "body": "❌ Build failed with 5 errors. Your immediate attention required.",
  "title": "Critical: Build Failure", 
  "level": "critical",
  "call": true
}

// Task completion notification
{
  "body": "✅ User authentication system completed. Ready for testing.",
  "title": "Task Complete",
  "level": "timeSensitive"
}

// Progress update
{
  "body": "📊 Database migration completed successfully (3/5 steps done).",
  "title": "Progress Update",
  "level": "active"
}

send_bark_batch_notifications

Send multiple notifications in a single batch operation. Use for notifying multiple team members or sending different priority updates.

Parameters:

  • notifications (required) - Array of notification objects (same format as single notification)

  • server_url (optional) - Bark server URL (defaults to BARK_SERVER_URL env var or https://api.day.app)

check_bark_server_health

Check if a Bark server is running and healthy. AI should call this proactively to ensure reliable user communication.

Parameters:

  • server_url (optional) - Bark server URL to check (defaults to BARK_SERVER_URL env var or https://api.day.app)

Getting Your Device Key

  1. Install Bark app on your iOS device

  2. Open the app and copy your device key from the main screen

  3. Use this key in the device_key parameter

Bark Server Setup

You can use:

  • The official Bark service: https://api.day.app

  • Self-hosted Bark server (see bark-server)

Development

# Watch mode for development
npm run dev

# Build
npm run build

# Start the server
npm start

License

MIT License

Available Tools

3 tools
check_bark_server_healthA

Check the health status of a Bark server. Use this to: (1) Verify notification system is working before important operations, (2) Troubleshoot notification delivery issues, (3) Monitor system health during automated workflows. Call this proactively to ensure reliable user communication.

ParametersJSON Schema
NameRequiredDescriptionDefault
server_urlNoBark server URL to check health

TDQS

A3.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. Description only says 'check health status'; lacks details on side effects, rate limits, or return behavior. Minimal disclosure beyond tautology.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences. Front-loaded with purpose and bullet-like usage guidelines. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema and description does not explain return values or format. Agent cannot anticipate what 'health status' response looks like.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single parameter. The description adds no new info beyond what the schema already states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool checks health status of a Bark server, with specific use cases. It is distinct from sibling tools that send notifications.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description explicitly lists three scenarios for use and advises proactive calling. No ambiguity about when to use versus siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

send_bark_batch_notificationsA

Send multiple push notifications via Bark to multiple iOS devices. Use this for batch operations like: (1) Notifying multiple team members about project completion, (2) Sending progress updates to different stakeholders, (3) Broadcasting important announcements. Each notification can have different priority levels based on recipient needs.

ParametersJSON Schema
NameRequiredDescriptionDefault
server_urlNoBark server URL (e.g., https://api.day.app)
notificationsYesArray of notifications to send

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided. The description only states that the tool sends notifications, but omits important behavioral details like handling of partial failures, rate limits, authentication requirements, or whether the operation is synchronous or asynchronous.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three concise sentences with clear examples. No unnecessary words or redundancy. Well-structured and front-loaded with the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description lacks information about return values, error handling, and potential limitations of batch operations. With no output schema, the description should clarify what the agent can expect after calling the tool, which it fails to do.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the input schema already documents all parameters. The description adds minor context about batch operations and priority levels but does not substantially enrich parameter meaning beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it sends multiple push notifications via Bark to multiple iOS devices. It provides specific use cases (notifying team members, stakeholders, broadcasting) that distinguish it from the single-notification sibling tool send_bark_notification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly lists batch operation scenarios: notifying multiple team members, sending progress updates, broadcasting announcements. While it implies when to use this tool, it does not explicitly state when not to use it or directly reference the alternative sibling tool send_bark_notification.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

send_bark_notificationA

Send a push notification via Bark to an iOS device. Use this to notify the user when: (1) Tasks are completed and need user attention, (2) Errors occur requiring user intervention, (3) User input or decisions are needed, (4) Testing or verification is required, (5) Long-running operations finish. Choose appropriate 'level' based on urgency: 'critical' for urgent issues, 'timeSensitive' for important updates, 'active' for general notifications.

ParametersJSON Schema
NameRequiredDescriptionDefault
server_urlNoBark server URL (e.g., https://api.day.app)
device_keyNoDevice key from Bark app
titleNoNotification title
subtitleNoNotification subtitle
bodyYesNotification content/message
urlNoURL to open when notification is tapped
groupNoGroup name for organizing notifications
iconNoCustom icon URL (iOS 15+)
soundNoCustom notification sound name
callNoPlay sound repeatedly for 30 seconds
levelNoNotification priority level: 'critical' for urgent issues requiring immediate attention (errors, failures), 'timeSensitive' for important updates during focus mode (task completion, testing needed), 'active' for general notifications (progress updates), 'passive' for low-priority background info
badgeNoBadge number on app icon
ciphertextNoEncrypted message content

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It describes sending notifications and urgency levels, but does not disclose error handling, rate limits, or potential side effects (e.g., if ciphertext is provided). It mentions encryption only in passing. Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, using a single paragraph with clear enumeration of use cases and level guidance. Every sentence adds value with no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 13 parameters (all documented in schema) and no output schema, the description covers the main functionality and usage. It does not explain return values or error handling, but for a notification tool this is acceptable. Context is reasonably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining when to use each 'level' enum (critical for urgent, timeSensitive for important updates, etc.), which goes beyond the schema's description. Other parameters repeat schema info, so this extra context justifies a 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Send a push notification via Bark to an iOS device', providing a specific verb and resource. It distinguishes from siblings (check_bark_server_health, send_bark_batch_notifications) by focusing on single push notifications.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly lists five scenarios when to use the tool (task completion, errors, user input needed, testing, long-running operations). It also provides guidance on choosing the 'level' based on urgency, though it does not explicitly state when not to use (e.g., for batch sends or health checks).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 3 tool updatesv1.2.0
    • First observedcheck_bark_server_health
    • First observedsend_bark_batch_notifications
    • First observedsend_bark_notification
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.2/5.0

Scored across 3 tools

Disambiguation5/5

Each tool has a distinct purpose: health check, single notification, batch notification. No overlap or ambiguity.

Naming Consistency5/5

All tools use consistent verb_noun pattern with snake_case (check_*, send_*). The batch variant extends naturally.

Tool Count5/5

Three tools cover the core operations of a notification server perfectly: health monitoring, individual send, and batch send.

Completeness5/5

The tool surface is complete for the domain, providing health check and both individual and batch notification sending without obvious gaps.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Related MCP Connectors

Related MCP Servers