Gotify MCP for AI. Automate system alerts and message management.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Gotify MCP connects your self-hosted push notification server to any AI agent. Use it to send high-priority system alerts, delete old messages, and manage all application and client tokens using natural language commands.
What your AI can do
Change password
Resets the password for the currently authenticated user.
Create application
Registers a new source (application) that is allowed to send messages through Gotify.
Create client
Generates and registers a new client token for a specific device or service.
Push specific messages with custom titles and priorities out to all connected devices.
Create, list, or remove the applications that authorize which services can send notifications.
Perform administrative tasks like creating users and changing passwords for your Gotify instance.
Retrieve or delete specific messages from the notification stream to keep logs clean.
Ask an AI about this
Waiting for input…
Gotify MCP: 22 Tools
These tools let you programmatically read and write all data associated with your Gotify notification system using natural language commands.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Gotify on VinkiusChange Password
Resets the password for the currently authenticated user.
Create Application
Registers a new source (application) that is allowed to send messages through Gotify.
Create Client
Generates and registers a new client token for a specific device or service.
Create User
Adds a new administrator user to the Gotify instance (admin only).
Delete All Messages
Wipes out every message associated with the current client token.
Delete Application
Removes an existing notification source application from the system.
Delete Client
Deactivates a specific device or service client token.
Delete Message
Removes one specific message record by its unique ID.
Get Applications
Lists all currently registered applications and their details.
Get Clients
Retrieves a list of all active or inactive client tokens.
Get Current User
Fetches the details and profile information for the authenticated user.
Get Health
Checks the overall operational status of the Gotify server instance.
Get Messages
Retrieves a list of historical messages associated with the current client token.
Get Plugin Config
Retrieves configuration details for any installed plugins on the server.
Get Plugin Display
Gets display information used by Gotify's internal plugin system.
Get Plugins
Lists all plugins currently installed and active on the server.
Get Users
Retrieves a list of every user account registered to the Gotify instance (admin...
Get Version
Returns the current software version information for the server.
Send Message
Sends a new message payload to all connected clients, using an application token.
Update Application
Modifies details or settings of an existing notification source application.
Update Client
Updates the credentials or metadata for a specific client token.
Update Plugin Config
Modifies the configuration settings of an installed plugin.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Gotify integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Gotify, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Gotify. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 22 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Dealing with alert systems means constant API calls.
Right now, if your system needs an alert—say, disk space hit 80%—you're stuck in a loop. You have to jump into the dashboard, grab the necessary tokens, maybe open Postman or curl something on a dedicated machine, and then manually paste everything together. It’s tedious, error-prone copy-pasting.
With this MCP, you just talk to your agent. You say, 'Alert: Disk space is low.' The agent handles all the token management, the correct endpoints, and sending the high-priority payload, doing it instantly from a single chat window. It cuts out every manual click.
The Gotify MCP gives you instant command over your system's alert resources.
You no longer need to manually navigate between user management UIs and the message stream. You can use `get_users` to audit access, then immediately run `update_client` to change a forgotten token—all without leaving your workspace. It’s total control.
The system is now reactive and conversational. Instead of performing a sequence of manual administrative steps, you delegate the entire workflow to your agent.
What your AI can actually do with this
This MCP lets you interact with your Gotify instance like a command line tool, but through conversation. Forget logging into the web UI or manually hitting API endpoints every time you need an alert. You can ask your AI agent to monitor your system health and push immediate notifications when something goes wrong.
Need to organize your alerts? The agent handles listing all applications so you know exactly what token belongs where. Want to clean up old messages? Just tell it to delete them.
If you're building complex workflows, Vinkius makes connecting this alert hub simple. You just subscribe once and give your AI client permission to manage the underlying structure—users, clients, apps—all from a single conversation.
019e38a3-afbd-731c-af80-0eb1f581c335 
Here's how it actually works
The bottom line is, you tell the AI what needs to be done with your alerts, and it handles all the technical connection details for you.
Subscribe to this MCP and enter your Gotify URL, along with the necessary Application or Client tokens.
Your AI agent authenticates against the server using these credentials. It verifies your permissions (e.g., admin rights vs. read-only access).
You issue a command—like 'Send an alert about database failure'—and the agent executes the specific API call to push the message.
Who is this actually for?
Anyone who manages distributed systems or automated processes. This MCP is essential for DevOps Engineers tired of clicking through dashboards at 2 a.m., Developers needing to test notification payloads without leaving their IDE, and System Admins who need instant control over alert management.
Automating alerts for CI/CD pipelines or server health checks directly from the terminal using structured commands.
Testing notification payloads and managing application tokens quickly to debug message flow without writing boilerplate API calls.
Maintaining user accounts, modifying client tokens, or clearing old messages across the entire notification infrastructure.
What Changes When You Connect
Stop manually checking logs. You can ask the agent to send a high-priority alert, like notifying you immediately when your build fails, without ever leaving your chat window or terminal. Just tell it what to push.
Manage all notification resources easily. Use tools like get_applications and create_application to keep track of every service that needs access, knowing exactly which tokens are live and who owns them.
Maintain a clean slate. If you need to clear out old, noisy messages from the stream, the agent handles it with one command, allowing you to use tools like delete_all_messages before running diagnostics.
Control user access immediately. Need to onboard a new team member or restrict an old service? You can run admin tasks like create_user or change_password, ensuring your system's security posture stays locked down.
Debug message flow instantly. If a notification isn't showing up, you can use the agent to get historical data via get_messages and check which apps are registered using get_applications—all in one conversation.
See it in action
CI/CD Pipeline Failure Alert
A developer pushes code, and the test suite fails at 3 a.m. Instead of waiting for an email or checking a dashboard, they prompt their agent: 'Send a critical alert to Gotify saying Build #45 failed on Server Beta.' The agent uses send_message immediately.
Onboarding New Services
A team needs a new microservice (Service Gamma) to send alerts. Instead of writing code to manage tokens, the admin asks the agent to 'Create and register a client for Service Gamma,' using create_client and getting the token right away.
Security Audit Cleanup
The security team needs to check if any old services are still sending messages. They ask the agent to list all registered apps (get_applications) and then delete specific, expired tokens using delete_client.
Debugging Message Delivery
A client reports that yesterday's alerts aren't visible. The developer asks the agent to retrieve messages from the last 24 hours (get_messages), quickly confirming if the payloads were sent and when.
The honest tradeoffs
Assuming global visibility
Trying to send a message without first ensuring the necessary application token exists, resulting in an API error stating 'Unauthorized source.'
Always check your resources first. Use get_applications and get_clients before attempting to send_message. If you need a new alert source, use create_application.
Over-admin rights usage
Running delete_all_messages without confirming the scope, which could wipe out critical audit logs for an entire deployment cycle.
Before running destructive tools like delete_all_messages, always call get_messages first. This confirms what data you're about to delete and ensures it's intentional.
Ignoring user roles
A standard developer trying to run an admin function like listing all users, which will fail because they lack the necessary permissions.
If you need to manage accounts, use get_current_user first. If that confirms your role is insufficient, you must escalate or use a dedicated administrator account for tasks like running create_user.
When It Fits, When It Doesn't
Use this MCP if your primary concern is programmatic control over structured, high-priority alerts and resource management within a self-hosted Gotify environment. You need to tell the system 'do this action' (e.g., send_message, delete_application). Don't use it if you are trying to search general knowledge or chat with people; for that, use a dedicated conversational agent framework. This MCP is purely about structured communication operations and account maintenance.
Questions you might have
How do I send an alert using the Gotify MCP? +
You use send_message. Just tell your agent the title and body of the message, and it pushes the notification out immediately. You'll need a valid application token for this.
What if I need to list all my existing apps? Do I use get_applications? +
Yes, you use get_applications. It runs through and lists every single notification source registered on your Gotify server. This is helpful when auditing system access.
Can I delete messages using the Gotify MCP? Which tool should I use? +
You use delete_message for a specific message or delete_all_messages to wipe out everything. Be careful with delete_all_messages; it's irreversible.
I need to change a user password; is that done through the Gotify MCP? +
Yep, you use change_password. This tool lets you reset passwords for users on your instance. You must have admin privileges for this.
I need to modify an existing notification source's details; should I use the `update_application` tool? +
Yep, you use update_application. This lets you change descriptions or other details for a specific application without having to delete and recreate it. It’s perfect for maintenance.
Before running alerts, how can I check if my Gotify server is actually operational? Should I use the `get_health` tool? +
Run get_health. This verifies the API status of your self-hosted instance. It confirms general connectivity and operational readiness before you try sending messages or managing other resources.
How do I see a list of all registered devices or tokens connected to my system? Is there a tool for that? +
You need the get_clients tool. This function retrieves details for every client registered on your instance, letting you audit which services are authorized to receive messages.
If I'm an admin and need to see all user accounts on the system, what do I use? Should I call `get_users`? +
Call get_users. This is an admin-only tool that lists every registered user account. It helps you manage who has access beyond just viewing applications or clients.
How do I send a notification to my phone using this server? +
Use the send_message tool. You'll need to provide a message and a title. Ensure you have configured your GOTIFY_APP_TOKEN so the server knows which application is sending the alert.
Can I clear all messages from my Gotify stream at once? +
Yes, you can use the delete_all_messages tool. This requires a valid GOTIFY_CLIENT_TOKEN to authorize the deletion of messages for that specific client.
Is it possible to create new application tokens via AI? +
Absolutely. Use the create_application tool with a name and optional description. The AI will return the details of the new application, including its token.
We've already built the connector for Gotify. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 22 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.