Ntfy Me MCP

What is Ntfy Me MCP about?

Ntfy Me MCP provides a Model Context Protocol (MCP) server that lets AI assistants push notifications to any ntfy.sh topic (public or self‑hosted) and fetch cached messages. It handles token‑based authentication, automatic URL detection, markdown rendering, and emoji tags, making notification creation effortless for AI workflows.

How to use Ntfy Me MCP?

1. Install – run npx ntfy-me-mcp (or use the Docker image gitmotion/ntfy-me-mcp).
2. Configure – set required environment variables (NTFY_TOPIC, optional NTFY_URL, NTFY_TOKEN, PROTECTED_TOPIC).
3. Add to MCP – include the server entry in your MCP configuration (see the serverConfig section).
4. Send – use the ntfy_me tool from an AI agent, providing taskTitle, taskSummary, and optional fields such as priority, tags, markdown, and actions.
5. Fetch – use the ntfy_me_fetch tool to retrieve recent messages, filter by title, tags, priority, or time range.

Key Features of Ntfy Me MCP

• One‑command setup via npx or Docker.
• Secure token handling with optional VS Code input masking.
• Automatic URL detection creates up to three view actions.
• Intelligent markdown detection enables rich formatting without extra flags.
• Emoji shortcodes for visual tags.
• Support for self‑hosted ntfy instances and protected topics.
• Message fetching with flexible filters (time, title, tags, priority, ID).
• Cross‑platform – works on any system with Node.js or Docker.

Use Cases of Ntfy Me MCP

• Build pipelines – notify developers when CI jobs finish or fail.
• AI‑driven assistants – alert users when long‑running tasks (code generation, data processing) complete.
• Monitoring – send real‑time alerts from scripts or agents to mobile devices.
• Team collaboration – push status updates to a shared ntfy topic for all members.
• Debugging – fetch recent logs or messages directly from the MCP server.

FAQ from the Ntfy Me MCP

Q: Do I need an ntfy account? A: No. Public topics on ntfy.sh are unauthenticated. For private topics or self‑hosted servers, provide an access token.

Q: Can I run the server without Docker? A: Yes, the preferred method is npx ntfy-me-mcp; Docker is optional for containerized environments.

Q: How many action buttons can a notification have? A: ntfy supports a maximum of three view actions; automatic URL detection respects this limit.

Q: Is markdown always enabled? A: The server auto‑detects markdown patterns and enables it. You can disable it manually with markdown: false.

Q: Where are fetched messages stored? A: Messages are cached on the ntfy server (public ntfy.sh retains up to 12 hours by default). The fetch tool retrieves whatever is available in that cache.

Q: How do I secure my token in VS Code? A: Add an input of type promptString with "password": true to your settings.json and reference it as ${input:ntfy_token} in the MCP server env.

ntfy-me-mcp

A streamlined Model Context Protocol (MCP) server for sending notifications via ntfy service (public or selfhosted with token support) 📲

Overview

ntfy-me-mcp provides AI assistants with the ability to send real-time notifications to your devices through the ntfy service (either public or selfhosted with token support). Get notified when your AI completes tasks, encounters errors, or reaches important milestones - all without constant monitoring.

The server includes intelligent features like automatic URL detection for creating view actions and smart markdown formatting detection, making it easier for AI assistants to create rich, interactive notifications without extra configuration.

Available via:

Name	Link / Badge
Glama.ai
Smithery.ai
MseeP.ai

Table of Contents

• Features
  • Coming soon...
• Quickstart - MCP Server Configuration
  • NPM / NPX (Recommended Method)
    • Minimal Configuration
    • Full Configuration
      • Option 1: Direct Token
      • Option 2: VS Code Inputs
  • Docker
    • Using with MCP in Docker
• Installation
  • Option 1: Install Globally
  • Option 2: Run with npx
  • Option 3: Install Locally
  • Option 4: Build and Use Locally
    • Using locally built server with MCP
  • Option 5: MCP Marketplace Installations
• Configuration
  • Environment Variables
• Usage
  • Authentication
  • Setting Up the Notification Receiver
  • Sending Notifications (ntfy_me tool)
    • Using Natural Language
    • Message Parameters
    • Action Links
    • Emoji Shortcodes
    • Markdown Formatting
  • Retrieving Messages (ntfy_me_fetch tool)
    • Using Natural Language
    • Message Parameters
    • Examples
  • Development
    • Building from Source
• License
• Contributing

Features

• 🚀 Quick Setup: Run with npx or docker!
• 🔔 Real-time Notifications: Get updates on your phone/desktop when tasks complete
• 🎨 Rich Notifications: Support for topic, title, priorities, emoji tags, and detailed messages
• 🔍 Notification Fetching: Fetch and filter cached messages from your ntfy topics
• 🎯 Smart Action Links: Automatically detects URLs in messages and creates view actions
• 📄 Intelligent Markdown: Auto-detects and enables markdown formatting when present
• 🔒 Secure: Optional authentication with access tokens
• 🔑 Input Masking: Securely store your ntfy token in your vs config!
• 🌐 Self-hosted Support: Works with both ntfy.sh and self-hosted ntfy instances

(Coming soon...)

• 📨 Email: Send notifications to email (requires ntfy email server configuration)
• 🔗 Click urls: Ability to customize click urls
• 🖼️ Image urls: Intelligent image url detection to automatically include image urls in messages and notifications
• 🏁 and more!

Quickstart - MCP Server Configuration

NPM / NPX (Recommended Method)

• Requires npm / npx installed on your system.
• This method is recommended for most users as it provides a simple & lightweight method to set up the server.

For the easiest setup with MCP-compatible assistants, add this to your MCP configuration:

Minimal configuration (for public topics on ntfy.sh)

{
  "ntfy-me-mcp": {
    "command": "npx",
    "args": ["ntfy-me-mcp"],
    "env": {
      "NTFY_TOPIC": "your-topic-name"
    }
  }
}

Full configuration (for private servers or protected topics)

Option 1: Direct token in configuration

{
  "ntfy-me-mcp": {
    "command": "npx",
    "args": ["ntfy-me-mcp"],
    "env": {
      "NTFY_TOPIC": "your-topic-name",
      "NTFY_URL": "https://your-ntfy-server.com",
      "NTFY_TOKEN": "your-auth-token" // Use if using a protected topic/server
    }
  }
}

Option 2: Using VS Code inputs for secure token handling (recommended)

Add this to your VS Code settings.json file:

"mcp": {
  "inputs": [
    { // Add this to your inputs array
      "type": "promptString",
      "id": "ntfy_token",
      "description": "Ntfy Token",
      "password": true
    }
  ],
  "servers": {
    // Other servers...
    "ntfy-me-mcp": {
      "command": "npx",
      "args": ["ntfy-me-mcp"],
      "env": {
        "NTFY_TOPIC": "your-topic-name",
        "NTFY_URL": "https://your-ntfy-server.com",
        "NTFY_TOKEN": "${input:ntfy_token}", // Use the input id variable for the token
        "PROTECTED_TOPIC": "true" // Prompts for token and masks it in your config
      }
    }
  }
}

With this setup, VS Code will prompt you for the token when starting the server and the token will be masked when entered.

Docker

Using with MCP in Docker

• Requires Docker installed on your system.
• This method is useful for running the server in a containerized environment.
• You can use the official Docker images available on Docker Hub or GitHub Container Registry.

Docker Images:

• gitmotion/ntfy-me-mcp:latest (Docker Hub)
• ghcr.io/gitmotion/ntfy-me-mcp:latest (GitHub Container Registry)

In your MCP configuration (e.g., VS Code settings.json):

"mcp": {
  "servers": {
    "ntfy-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "NTFY_TOPIC",
        "-e",
        "NTFY_URL",
        "-e",
        "NTFY_TOKEN",
        "-e",
        "PROTECTED_TOPIC",
        "gitmotion/ntfy-me-mcp", // OR use ghcr.io/gitmotion/ntfy-me-mcp:latest
      ],
      "env": {
        "NTFY_TOPIC": "your-topic-name",
        "NTFY_URL": "https://your-ntfy-server.com",
        "NTFY_TOKEN": "${input:ntfy_token}",
        "PROTECTED_TOPIC": "true"
      }
    }
  }
}

Installation

If you need to install and run the server directly (alternative to the MCP configuration above):

Option 1: Install globally

npm install -g ntfy-me-mcp

Option 2: Run with npx

npx ntfy-me-mcp

Option 3: Install locally

# Clone the repository
git clone https://github.com/gitmotion/ntfy-me-mcp.git
cd ntfy-me-mcp

# Install dependencies
npm install

# Copy the example environment file and configure it
cp .env.example .env
# Edit .env with your preferred editor and update the variables
# nano .env  # or use your preferred editor

# Build the project
npm run build

# Start the server
npm start

Option 4: Build and use locally with node command

If you're developing or customizing the server, you might want to run it directly with node:

# Clone the repository
git clone https://github.com/gitmotion/ntfy-me-mcp.git
cd ntfy-me-mcp

# Install dependencies
npm install

# Copy the example environment file and configure it
cp .env.example .env
# Edit the .env file to set your NTFY_TOPIC and other optional settings
# nano .env  # or use your preferred editor

# Build the project
npm run build

# Run using node directly
npm start

Using locally built server with MCP

When configuring your MCP to use a locally built version, specify the node command and path to the built index.js file:

{
  "ntfy-me": {
    "command": "node",
    "args": ["/path/to/ntfy-mcp/build/index.js"],
    "env": {
      "NTFY_TOPIC": "your-topic-name"
      //"NTFY_URL": "https://your-ntfy-server.com", // Use if using a self-hosted server
      //"NTFY_TOKEN": "your-auth-token" // Use if using a protected topic/server
    }
  }
}

Remember to use the absolute path to your build/index.js file in the args array.

Option 5: MCP Marketplace installations

Installing via Smithery

To install ntfy-me-mcp for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @gitmotion/ntfy-me-mcp --client claude

Configuration

Environment Variables

Create a .env file in your project directory by copying the provided example:

# Copy the example file
cp .env.example .env

# Edit the file with your preferred editor
nano .env  # or vim, code, etc.

Your .env file should contain these variables:

# Required
NTFY_TOPIC=your-topic-name

# Optional - Configure these if using a private/protected ntfy server
# NTFY_URL=https://ntfy.sh  # Default is ntfy.sh, change to your self-hosted ntfy server URL if needed
                            # Include port if needed, e.g., https://your-ntfy-server.com:8443
# NTFY_TOKEN=your-access-token  # Required for authentication with protected topics/servers
# PROTECTED_TOPIC=false  # Set to "true" if your topic requires authentication (helps prevent auth errors)

Note: The PROTECTED_TOPIC flag helps the application determine whether authentication is required for your topic. When set to "true" and no token is provided, you'll be prompted to enter one. This prevents authentication failures with protected topics.

Usage

Authentication

This server supports both authenticated and unauthenticated ntfy endpoints:

• Public Topics: When using public topics on ntfy.sh or other public servers, no authentication is required.
• Protected Topics: For protected topics or private servers, you need to provide an access token.

If authentication is required but not provided, you'll receive a clear error message explaining how to add your token.

Setting Up the Notification Receiver

1. Install the ntfy app on your device
2. Subscribe to your chosen topic (the same as your NTFY_TOPIC setting)

Sending Notifications (ntfy_me tool)

This section covers all functionality related to sending notifications using the ntfy_me tool.

Using Natural Language

When working with your AI assistant, you can use natural phrases like:

"Send me a notification when the build is complete"
"Notify me when the task is done"
"Alert me after generating the code"
"Message me when the process finishes"
"Send an alert with high priority"

Message Parameters

The tool accepts these parameters:

Parameter	Description	Required
taskTitle	The notification title	Yes
taskSummary	The notification body	Yes
priority	Message priority: min, low, default, high, max	No
tags	Array of notification tags (supports emoji shortcodes)	No
markdown	Boolean to enable markdown formatting (true/false)	No
actions	Array of view action objects for clickable links	No

Example:

{
  taskTitle: "Code Generation Complete",
  taskSummary: "Your React component has been created successfully with proper TypeScript typing.",
  priority: "high",
  tags: ["check", "code", "react"]
}

This will send a high-priority notification with a checkmark emoji.

Action Links

You can add clickable action buttons to your notifications using the actions parameter, or let the server automatically detect URLs in your message.

Automatic URL Detection

When URLs are present in the message body, the server automatically creates up to 3 view actions (ntfy's maximum limit) from the first detected URLs. This makes it easy to include clickable links without manually specifying the actions array.

For example, this message:

{
  taskTitle: "Build Complete",
  taskSummary: "Your PR has been merged! View the changes at https://github.com/org/repo/pull/123 or check the deployment at https://staging.app.com"
}

Will automatically generate view actions for both URLs, making them easily clickable in the notification.

Manual Action Configuration

For more control, you can manually specify actions:

Property	Description	Required
action	Must be "view"	Yes
label	Button text to display	Yes
url	URL to open when clicked	Yes
clear	Whether to clear notification on click (optional)	No

Example with action links:

{
  taskTitle: "Pull Request Review",
  taskSummary: "Your code has been reviewed and is ready for final checks",
  priority: "high",
  tags: ["check", "code"],
  actions: [
    {
      action: "view",
      label: "View PR",
      url: "https://github.com/org/repo/pull/123"
    },
    {
      action: "view",
      label: "View Changes",
      url: "https://github.com/org/repo/pull/123/files",
      clear: true
    }
  ]
}

Emoji Shortcodes

You can use emoji shortcodes in your tags for visual indicators:

• warning → ⚠️
• check → ✅
• rocket → 🚀
• tada → 🎉

See the full list of supported emoji shortcodes.

Markdown Formatting

Your notifications support rich markdown formatting with intelligent detection! When you include markdown syntax in your taskSummary, the server automatically detects it and enables markdown parsing - no need to set markdown: true explicitly.

Automatic Detection

The server checks for common markdown patterns like:

• Headers (#, ##, etc.)
• Lists (-, *, numbers)
• Code blocks (```)
• Links (text)
• Bold/italic (text, text)

When these patterns are detected, markdown parsing is automatically enabled for the message.

Manual Override

While automatic detection works in most cases, you can still explicitly control markdown parsing:

{
  taskTitle: "Task Complete",
  taskSummary: "Regular plain text message",
  markdown: false  // Force disable markdown parsing
}

Retrieving Messages (ntfy_me_fetch tool)

This section covers all functionality related to fetching and filtering messages using the ntfy_me_fetch tool.

Using Natural Language

AI assistants understand various ways to request message fetching:

"Show me my recent notifications"
"Get messages from the last hour"
"Find notifications with title 'Build Complete'"
"Search for messages with the test_tube tag"
"Show notifications from the updates topic from the last 24hr"
"Check my latest alerts"

Message Parameters

The tool accepts these parameters:

Parameter	Description	Required
ntfyTopic	Topic to fetch messages from (defaults to NTFY_TOPIC env var)	No
since	How far back to retrieve messages ('10m', '1h', '1d', timestamp, message ID, or 'all')	No
messageId	Find a specific message by its ID	No
messageText	Find messages containing exact text content	No
messageTitle	Find messages with exact title/subject	No
priorities	Find messages with specific priority levels	No
tags	Find messages with specific tags	No

Examples

1. Fetch Recent Messages

{
  since: "30m"; // Get messages from last 30 minutes
}

2. Filter by Title and Priority

{
  messageTitle: "Build Complete",
  priorities: "high",
  since: "1d"
}

3. Search Different Topic with Tags

{
  ntfyTopic: "updates",
  tags: ["error", "warning"],
  since: "all"
}

4. Find Specific Message

{
  messageId: "xxxxXXXXxxxx";
}

Messages are returned with full details including:

• Message ID and timestamp
• Topic and title
• Content and priority
• Tags and attachments
• Action links and expiration

Note: Message history availability depends on your ntfy server's cache settings. The public ntfy.sh server typically caches messages for 12 hours.

Development & Contributions

Building from Source

git clone https://github.com/gitmotion/ntfy-me-mcp.git
cd ntfy-me-mcp
npm install
npm run build

License

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

Contributing

Contributions are welcome! Please follow these guidelines:

• Point your pull requests to the dev or testing branches (not main).
• For all logging, use the Logger class abstraction:
  • Replace any console.log, console.warn, or console.error with logger.info, logger.warn, or logger.error.
• Ensure your code is clean, well-documented, and passes all tests.
• Clearly describe your changes in the PR description.
• For local testing:
  • Build the project with npm run build.
  • Run the server locally using npm start or node build/index.js.
  • Test your changes before submitting a PR.

Thank you for helping improve ntfy-me-mcp!

---

Made with ❤️ by gitmotion