Skip to main content
Glama
ntfy-mcp-server

ntfy-mcp-server

by cyanheads

Version License Docker MCP SDK npm TypeScript Bun

Install in Claude Desktop Install in Cursor Install in VS Code

Framework


Overview

Push notifications to your phone or desktop through ntfy. Publish, update, and manage notifications, poll a topic's recent history, and look up emoji short codes for tags.

Tools

Tool

Description

ntfy_publish_message

Send or update a push notification on an ntfy topic.

ntfy_manage_message

Clear or delete a previously-sent notification by sequence_id.

ntfy_fetch_messages

Poll cached messages from one or more topics with optional filters.

ntfy_search_emoji_tags

Look up ntfy emoji tag short codes for use in tags.

Resources

Resource

Description

ntfy://{topic}

Snapshot of a topic — latest 20 messages from the past hour, plus the topic's browser URL.

ntfy_fetch_messages covers the same topic data with custom windows and filters when the resource's fixed defaults aren't enough.

Skills

Skill

Description

ntfy-guide

Using the ntfy_* tools: choosing the topic, carrying one sequence id through a notification's updates, clear, and delete, scheduling and cancelling reminders, and reading fetched history without miscounting

Plugin, npm, Docker, and MCPB installs ship it from skills/; MCP clients that support the Skills extension read it as skill://ntfy-guide/SKILL.md.

Related MCP server: ntfy-me-mcp

Capability reference

ntfy_publish_message tool

  • Topics are created on first publish — treat the topic name as a secret; anyone who knows it can publish or subscribe

  • Takes title, priority (1–5), tags, click, attach, icon, filename, markdown (rendered by the web app and the Android app), delay, timezone, email, call, cache, firebase, and up to three action buttons (view, broadcast, http, copy); body capped at 4096 bytes, empty body defaults to triggered; pass the original sequence_id to update a sent message

  • delay takes a duration, a Unix timestamp, an RFC 3339 time with its Z or ±hh:mm offset, or a natural-language time; ntfy reads a natural-language time in timezone (an IANA zone name) when set, otherwise in its own server's timezone. email: "yes" uses the account's primary verified address

  • Publishes with email, call, or a broadcast/http button ask the user to confirm the target before sending; declining fails with consent_declined

  • A per-call base_url gets credentials only if it matches a registered server (NTFY_BASE_URL or an NTFY_SERVERS entry); otherwise the request is unauthenticated. A base URL may not carry user:password@; credentials are set through the auth fields

  • Every successful call reports quota: the daily messages allowance and the requests burst, each with its limit and remaining, when ntfy reports them (ntfy v2.37.0 and later)

  • Failures carry typed reasons: payload_too_large (body, attachment, title, combined tags, or the request as a whole over ntfy's limits), invalid_delay, invalid_timezone (a timezone ntfy doesn't know, checked only when delay is set), invalid_attachment (malformed attach URL, or filename without attach), and unverified_contact (email/call without a verified address or number, or without auth), alongside the shared reasons under Features


ntfy_manage_message tool

  • operation: clear marks the notification read and dismisses it (subscribers see message_clear); delete removes it from the drawer (subscribers see message_delete)

  • Every call asks the user to confirm the topic, sequence_id, and operation first; declining fails with consent_declined

  • Reports quota on every successful call, as ntfy_publish_message does

  • The original message stays in cache, and repeating an operation is safe; ntfy.sh accepts an unknown sequence_id, stricter deployments return not_found


ntfy_fetch_messages tool

  • Returns a snapshot of cached messages; wait_seconds (default 0, at most 40 per call) holds ntfy's stream open when the poll matches nothing and returns the first matching message to arrive, or the empty result when the time is up (pass the last message's id as since to wait for the next one; a row with the same time may have been published just before it). Accepts comma-separated topics (e.g. alerts,backups, each 1–64 characters) and filters since (duration / Unix timestamp in seconds / message ID / all / latest), priority, tags, id, title, message, plus scheduled to include delayed messages; a still-queued row comes back scheduled: true, and its time is the delivery time

  • Default window 10m, default limit 20, at most 100 per call (a larger limit is served as 100 with a notice, and a larger wait_seconds as 40; NTFY_CLAMP_LIMITS=false rejects it instead); a larger window returns the newest limit messages with totalCount and a nextCursor to pass back as cursor. Bodies truncate at ~500 UTF-16 code units, on a code-point boundary (messageTruncated gives the dropped count in that unit); refetch with id for the full text. Rows carry icon, encoding, and an action id when ntfy sent them. upstreamTruncated flags a replay ntfy capped

  • A numeric since is Unix seconds: a value of 10¹² or more (a millisecond timestamp) is rejected, and a value under 10⁹ or a 12-digit number gets a notice, since ntfy would read it as a time before 2001 (a bare 10 is 1970) or as a message ID

  • Failures carry typed reasons: invalid_since (malformed since value, or a numeric one of 10¹² or more), cursor_not_found (the cursor's message expired, or came from a call with different topics, since, or filters), and upstream_malformed (the response wasn't an ntfy message stream), alongside the shared reasons under Features


ntfy_search_emoji_tags tool

  • Case-insensitive match on part of a tag name, with surrounding colons dropped and spaces or hyphens read as _ (:warning:, heavy check), or on one emoji, with or without a skin tone or variation selector; effectiveQuery returns the normalized query. A tag named exactly by the query comes first, the rest in reference order. Omit query to list the reference in order

  • limit default 25, at most 200 per call (a larger value is served as 200 with a notice; NTFY_CLAMP_LIMITS=false rejects it instead); page with offset using totalCount

  • Returned tag strings go straight into ntfy_publish_message's tags

  • On by default; set NTFY_ENABLE_EMOJI_TAGS=false to remove it from tools/list


ntfy://{topic} resource

  • Fixed snapshot: latest 20 messages from the past hour plus the topic's browser URL, in the same shape as ntfy_fetch_messages (including upstreamTruncated)

  • For custom windows or filters, use ntfy_fetch_messages

Features

Built on @cyanheads/mcp-ts-core: stdio and Streamable HTTP transports, pluggable auth (none / jwt / oauth), swappable storage (in-memory, filesystem, Supabase, Cloudflare KV/R2/D1), structured logging with optional OpenTelemetry tracing.

ntfy-specific:

  • Retrying ntfy client with a per-attempt timeout, and each call capped at 50 s so it settles before an MCP client's 60 s default

  • Per-server auth: credentials bind to each registered base URL (NTFY_BASE_URL or an NTFY_SERVERS entry), with bearer-token and basic-auth modes mutually exclusive

  • User confirmation before a clear/delete, or a publish with email, call, or a broadcast/http button, on both stdio and Streamable HTTP

  • Optional SSRF guard on base_url overrides (NTFY_BLOCK_PRIVATE_HOSTS); registered servers are exempt

  • Bundled emoji-tag reference, regenerated from upstream docs/ntfy/emojis.md via scripts/build-emoji-tags.ts

Agent-friendly output:

  • Publish and manage echo the resolved topic, ID, and timestamp, and report the remaining quota; fetch also echoes the resolved since and applied filters

  • Typed reason codes let callers branch on failure mode. Shared across the tools and the resource: forbidden_topic (ntfy refused the topic with 401/403: missing or insufficient credentials), rate_limited (429 after retries; data.limit names which limit ntfy hit, when its error says), upstream_unreachable (network failure, a 5xx that outlasted retries or whose Retry-After the call can't wait out, or no complete answer within the 50 s call deadline; carries retryAfter when ntfy sent one), upstream_malformed (a reply that isn't ntfy's message format or couldn't be read in full; publish and manage don't retry it, since the event may already be out), not_ntfy_endpoint (the answer didn't come from an ntfy topic route: a non-2xx answer without ntfy's JSON error envelope on a status no other reason claims, such as a 404, 405, or 501, or a proxy's 401 or 403, or ntfy's own 40401 page not found; the code stays the one the HTTP status maps to, an answer without the envelope names the host the request was sent to, and ntfy_manage_message keeps every 404 as not_found). consent_declined, not_found, and the rest are listed per entry

  • Fetch and emoji search report truncated, totalCount, and a notice naming the next step (pass nextCursor as cursor, advance offset)

Getting started

Add it to Claude Code:

claude mcp add ntfy-mcp-server -- npx -y ntfy-mcp-server

For other clients, add this to the MCP config file:

{
  "mcpServers": {
    "ntfy-mcp-server": {
      "command": "npx",
      "args": ["-y", "ntfy-mcp-server"]
    }
  }
}

Public ntfy.sh works without an account. Set NTFY_DEFAULT_TOPIC so calls can omit topic; for protected topics, add NTFY_AUTH_TOKEN (generate one at https://ntfy.sh/account). With claude mcp add, pass each as -e NAME=value after the server name; in JSON, put them under env. For Docker, a source build, or Streamable HTTP, see Running the server.

Configuration

Variable

Description

Default

NTFY_SERVERS

JSON array of { baseUrl, authToken? | authUsername?+authPassword? } entries, one per ntfy server; the first is the default. A baseUrl may not carry user:password@; startup fails on one. Takes precedence over the single-server vars below.

—

NTFY_BASE_URL

Single-server shorthand — base URL of the ntfy server (no trailing slash, no user:password@; credentials go in the auth variables below). Used when NTFY_SERVERS is unset.

https://ntfy.sh

NTFY_DEFAULT_TOPIC

Topic used when a tool call omits topic.

—

NTFY_AUTH_TOKEN

Bearer access token (tk_…) for the single-server shorthand. Mutually exclusive with NTFY_AUTH_USERNAME / NTFY_AUTH_PASSWORD.

—

NTFY_AUTH_USERNAME

Basic-auth username for the single-server shorthand — required together with NTFY_AUTH_PASSWORD.

—

NTFY_AUTH_PASSWORD

Basic-auth password for the single-server shorthand — required together with NTFY_AUTH_USERNAME.

—

NTFY_REQUEST_TIMEOUT_MS

Per-attempt HTTP timeout in milliseconds. Each call is also capped at 50 s across all attempts.

15000

NTFY_MAX_RETRIES

Max retry attempts for transient upstream failures (5xx, network, 429).

3

NTFY_BLOCK_PRIVATE_HOSTS

When true, a per-call base_url override must resolve to a public address and redirects are not followed. Registered servers are exempt. Turn it on where callers you don't control can reach the server.

false

NTFY_CLAMP_LIMITS

When true, a limit above a tool's per-call cap (100 for ntfy_fetch_messages, 200 for ntfy_search_emoji_tags), or a wait_seconds above 40, is served as the cap with a notice, and the schema advertises no maximum. Set to false to advertise and enforce the cap as a schema maximum, rejecting a larger value.

true

NTFY_ENABLE_EMOJI_TAGS

Set to false to disable ntfy_search_emoji_tags. An unrecognized value fails startup.

true

MCP_TRANSPORT_TYPE

Transport: stdio or http.

stdio

MCP_SESSION_MODE

HTTP session model: auto, stateful, or stateless. Over HTTP this server requires stateful (auto resolves to it); stateless is refused at start. Ignored on stdio.

stateful

MCP_HTTP_HOST

HTTP host.

127.0.0.1

MCP_HTTP_PORT

HTTP port.

3010

MCP_HTTP_ENDPOINT_PATH

HTTP endpoint path.

/mcp

MCP_AUTH_MODE

Auth mode: none, jwt, or oauth.

none

MCP_REQUEST_STATE_KEY

Recommended for HTTP. Key (≥ 32 bytes, e.g. openssl rand -base64 32, the same on every instance) that seals the consent requestState for 900 s; an invalid or expired state is rejected with -32602 invalid_request_state.

—

STORAGE_PROVIDER_TYPE

Where consent records live (600 s TTL). Multi-instance HTTP needs shared storage: filesystem (shared volume), supabase, or cloudflare-d1, not cloudflare-kv.

in-memory

MCP_LOG_LEVEL

Log level (RFC 5424).

info

LOGS_DIR

Directory for file-based logs (Node only; ignored on Workers).

./logs

LOG_TOOL_FAILURE_PAYLOADS

Log each failed tool call's arguments and result, redacted by key name and capped at LOG_TOOL_FAILURE_PAYLOAD_MAX_BYTES (default 16384). A secret inside a free-form value is not redacted.

false

OTEL_ENABLED

Enable OpenTelemetry instrumentation (spans, metrics, completion logs).

false

See .env.example for the full list of optional overrides.

Running the server

Local development

Requires Bun v1.4.4 or higher (or Node.js v24+) and a topic on an ntfy server. Public ntfy.sh needs no account; self-hosted instances and protected topics may need a bearer token or basic-auth credentials.

  • Clone and install:

    git clone https://github.com/cyanheads/ntfy-mcp-server.git
    cd ntfy-mcp-server && bun install
    cp .env.example .env   # set NTFY_DEFAULT_TOPIC (and auth, if needed)
  • Build and run:

    # One-time build
    bun run rebuild
    
    # Run the built server
    bun run start:stdio
    # or
    bun run start:http

    For Streamable HTTP:

    MCP_TRANSPORT_TYPE=http MCP_HTTP_PORT=3010 NTFY_DEFAULT_TOPIC=your-topic bun run start:http
    # Server listens at http://127.0.0.1:3010/mcp
  • Run checks and tests:

    bun run devcheck     # Lint, format, typecheck, security, changelog sync
    bun run test         # Vitest test suite
    bun run lint:mcp     # Validate MCP definitions against spec

Docker

docker run --rm -e NTFY_DEFAULT_TOPIC=your-topic -p 3010:3010 ghcr.io/cyanheads/ntfy-mcp-server:latest

The image defaults to HTTP transport, stateful session mode, and logs to /var/log/ntfy-mcp-server. To run it over stdio from an MCP client, use "command": "docker" with "args": ["run", "-i", "--rm", "-e", "MCP_TRANSPORT_TYPE=stdio", "-e", "NTFY_DEFAULT_TOPIC=your-topic", "ghcr.io/cyanheads/ntfy-mcp-server:latest"]. To build locally, docker build -t ntfy-mcp-server .. OpenTelemetry peer dependencies are installed by default — build with --build-arg OTEL_ENABLED=false to omit them.

Project structure

Directory

Purpose

src/index.ts

createApp() entry point — registers tools and resources, initializes services.

src/config

Server-specific environment variable parsing (NTFY_*) with Zod.

src/mcp-server/tools

Tool definitions (*.tool.ts).

src/mcp-server/resources

Resource definitions (*.resource.ts).

src/services/ntfy

ntfy HTTP client, types, and error classifier.

src/services/emoji-tags

Bundled emoji short-code reference and lookup service.

skills/

Agent Skills the server publishes (ntfy-guide), served over MCP via createApp({ skills: 'skills' }).

docs/ntfy

Mirrored upstream ntfy API docs (pinned commit in SOURCES.md).

tests/

Unit and integration tests mirroring src/.

Development guide

See CLAUDE.md for development guidelines and architectural rules. The short version:

  • Handlers throw, framework catches — no try/catch in tool logic

  • Use ctx.log for request-scoped logging, ctx.state for tenant-scoped storage

  • Wrap external API calls: validate raw → normalize to domain type → return output schema; never fabricate missing fields

  • Per-tool errors[] contracts stay inline — repetition is intended for locality

Contributing

Issues are welcome. Run checks and tests before submitting:

bun run devcheck
bun run test

License

Apache-2.0 — see LICENSE for details.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A streamlined MCP server that enables AI assistants to send real-time notifications to your devices through the ntfy service, allowing you to receive alerts when tasks complete or important events occur.
      2
      190 npm
      77
      GPL 3.0
    • A
      license
      C
      quality
      D
      maintenance
      MCP server for sending notifications to ntfy.sh or self-hosted ntfy instances.
      2
      13 npm
      MIT