Prompt Library for Agencies. Copy, Paste, Answer.
Twenty ready-to-run prompts for the work that fills your week: checking mail records, watching certificate deadlines, shepherding DNS moves, triaging outages, writing client reports. Ten of them run right now, no account required. The other ten work with your own monitoring data once you connect your AI assistant. Read-only, always.
Made and Hosted in the
European Union
GDPR-Compliant Hosting
in Germany
GEO-Redundant Replica
across the EU
The assistant does not guess. It measures.
The Uptimeify Prompt Library is a public collection of twenty ready-to-run prompts that let an AI assistant execute real checks through the MCP server: DNS, mail authentication, TLS, HTTP headers, reachability, plus your own monitors, incidents and uptime figures. Every prompt is built so the answer rests on real queries and arrives in a shape you can hand on.
- Output you can forward, so an answer lands as a handover record, a task list or a client email instead of a wall of chat.
- Ten prompts before you have an account, so you can test whether this helps in daily work before anyone signs anything.
- Ten prompts on your own portfolio, so monitoring data turns into the client SLA report without a spreadsheet in between.

Streamable HTTP, stateless, no session state between calls.
POST https://uptimeify.io/mcpThe server card describes the server in machine-readable form, and discovery follows RFC 8414 and RFC 9728.
GET https://uptimeify.io/.well-known/mcp/server-card.jsonA call outside the allowlist ends with 403 and data.code = agentTokenReadOnly.
Every prompt on this page uses deinkunde.com. Swap it for whichever domain is on your desk right now.
The twenty prompts at a glance
Every prompt with its access level and the job it does. Jump straight to the one you need.
One URL in your assistant. That is the whole setup.
Uptimeify runs an MCP server (Model Context Protocol, the open standard AI assistants use to call external tools). The endpoint speaks Streamable HTTP at https://uptimeify.io/mcp and is stateless. Add it, approve the access, run a prompt.
- Nothing to install, so there is no npm package and no wrapper for you to maintain.
- An API token only where you want one, so a client can log in over OAuth instead of holding a secret in a config file.
- Scope you set at creation, so a customer-bound token sees exactly one client and nothing next door.

Add the URL in your assistant as a remote MCP server and hit Connect. The client registers itself, you sign in to Uptimeify and approve. The consent screen states read-only access to your monitors, incidents and status pages.
The issued access inherits exactly your own permissions, nothing beyond.
Or create a token under Settings, API tokens, and send it as a header. The token is shown once.
Authorization: Bearer wsm_your_tokenClients that speak no HTTP transport bridge through mcp-remote.
npx -y mcp-remote https://uptimeify.io/mcpLeave the Authorization header off and the check tools still answer. Only the account-bound tools ask for it.
Twenty prompts, one endpoint
The first ten need no sign-in — they inspect everything visible from the outside. The other ten read your own monitors, incidents and uptime figures once you are connected. Filter down to the group you need; every card says which it is.
20 of 20 prompts
Tools: mx_lookup, spf_check, dkim_check, dmarc_check
Check every mail record for deinkunde.com and tell me what is missing. Specifically: MX, SPF, DMARC, and DKIM for the selectors default, google, k1, s1, selector1 and selector2. Give me a table with record type, value found, verdict and finding. Sort the findings by how badly each one hurts deliverability. For every finding, write out the DNS record that needs to be set, ready to copy.What you get: An inventory you can paste straight into the ticket. That last sentence is the difference between a diagnosis and finished work.
Tools: check_dns, mx_lookup, whois, domain_expiry, check_ssl, http_headers, redirect_check, response_time
Run a technical inventory of deinkunde.com before we take this client over. Check: A and AAAA records, MX, nameservers, WHOIS including domain expiry, the TLS certificate with issuer and remaining validity, the HTTP response headers, the redirect chain from http://deinkunde.com, and the response time. Write it up as a handover record: first the current state as bullets, then a list of what we should touch in week one, one sentence of reasoning each.What you get: The document that sits on the table at kickoff. It shows the client on day one that somebody actually looked.
Tools: domain_expiry, whois, check_ssl
Here are our domains: deinkunde.com, shop.deinkunde.com, mail.deinkunde.com, client-two.example, client-three.example. For each one, check the domain registration expiry and the remaining validity of the TLS certificate. Give me a table sorted by the tightest deadline: domain, registration expires, certificate expires, days left, issuer. Flag anything under 30 days. For those, write a short client email each: what expires, what happens if nobody acts, what we recommend. Matter of fact, no alarm.What you get: The overview nobody else has, because nobody checks fifty domains by hand. An expired domain is the most expensive avoidable outage in any portfolio.
Tools: dns_propagation, check_dns
We moved the A records of deinkunde.com to the new IP 203.0.113.10. Check DNS propagation across all available resolvers and tell me which ones still serve the old value. Give me the current TTL and estimate from it how much longer we should wait before shutting the old server down. Finish with the one line I post in the project channel to report status.What you get: A shutdown decision backed by data instead of by nerve.
Tools: spf_check, dkim_check, dmarc_check, mx_lookup, check_dns, dnsbl_check, reverse_dns
The client reports that email from deinkunde.com lands in spam. Work through it systematically: SPF, DKIM for the selectors default and google, DMARC, MX records. Resolve the MX hosts to IP addresses, check those against the common DNS blacklists, and verify the PTR record matches the mail server hostname. Finish with one sentence naming the most likely cause. Then the remedies in the order I should work through them, with rough effort per step. If an IP is listed, write the delisting request as a ready paragraph.What you get: A cause instead of a hunch, an order instead of a list, and in the worst case the request that otherwise eats twenty minutes of drafting.
Tools: dmarc_check, spf_check, dkim_check
Read the current DMARC record for deinkunde.com and explain in plain language what it does today. Check SPF and DKIM first, so we know whether tightening is safe. Then draft a staged plan from p=none through p=quarantine to p=reject: per stage the exact record value, the recommended run time, and the signal that tells me I am clear to move on.What you get: A plan instead of a switch. Turning DMARC on is easy. Turning it on without collateral damage is not.
Tools: redirect_check, check_ssl, hsts_check
Audit the full HTTPS chain for deinkunde.com: the redirect path from http://deinkunde.com and from http://www.deinkunde.com, the TLS certificate with issuer, validity and covered hostnames, and the HSTS configuration. Tell me whether every variant lands on the canonical HTTPS URL in exactly one hop. List every redundant redirect separately and tell me what it costs.What you get: The answer to why the site feels slow even though the server is fast.
Tools: http_headers, hsts_check
Fetch the HTTP response headers for https://deinkunde.com and rate them. Look specifically at Strict-Transport-Security, Content-Security-Policy, X-Content-Type-Options, Referrer-Policy and X-Frame-Options. Give me a table with header, current value, verdict and recommended value. Sort by impact per effort and flag the three I should set first. For each of those, name the risk of setting it too strictly.What you get: A priority order instead of a completeness checklist. That last sentence is what keeps a CSP from taking half the site offline.
Tools: website_status, response_time, check_dns, port_check, ping_test
deinkunde.com is reportedly unreachable. Run first triage: pull the site status, measure the response time, check DNS resolution, test whether port 80 and 443 are reachable, and run a ping test. Tell me first, in one sentence, whether this is DNS, network, server or application. Details after that. If the data does not support a clear call, say so instead of guessing.What you get: A direction, before anyone starts reading the wrong log.
Tools: response_time, check_dns, ping_test, port_check, asn_lookup, ip_geolocation, reverse_dns
deinkunde.com responds slowly. Narrow it down: measure the response time with its individual phases, check DNS resolution, run a ping test against the host, test port 443, and find the network operator, location and PTR record of the target IP. Tell me which part of the chain eats the time: DNS resolution, connect, TLS handshake, or the application itself. Give the measured value and a realistic target per phase. Summarise in two sentences I can forward to the hosting provider as is.What you get: The breakdown that turns "feels slow" into an addressable task, plus the lines for the hosting support ticket.
Tools: list_monitors, list_incidents
List all my monitors and pull the incidents from the last seven days. Give me a briefing in three blocks: first everything still open, second the clients with the most incidents this week, third a one-liner for everything that stayed quiet. Keep it under 200 words. I read this before the first coffee.What you get: The week in one paragraph. Works as a recurring task too, if your assistant supports schedules.
Tools: list_monitors, monitor_status
List all my monitors and group them by client. Then show me where coverage is thin: clients with a single monitor, monitors currently paused or in maintenance, and clients where the website is watched but no mail service and no certificate. Turn that into a task list sorted by client, one sentence each on what I should add and why it helps that client.What you get: The gaps that usually surface only when something falls through one. And the outline of your next upsell conversation.
Tools: list_incidents, monitor_status, check_history
Pull the incidents from the last 24 hours and the current status of every affected monitor. Write a shift handover for the on-call responder: what is open, what just closed and might come back, what was a one-off. Per item name the monitor, the client, the time and the state. Finish with one sentence: what should on-call watch tonight in particular?What you get: The handover that otherwise happens as a 6:40pm voice note nobody can find in the morning.
Tools: list_incidents, monitor_status
Show me the last five incidents across my portfolio and the current status of the affected monitor. From that, write a status update for the client: what happened, since when, what we are doing right now, when the next update comes. Calm tone, no blame, no speculation about root cause, 120 words maximum. Then the same message again as a two-line version for the phone.What you get: The message that otherwise sits unwritten between two terminal windows.
Tools: check_history, monitor_status
Take the monitor with ID [ID] and pull the check history for [date] between 08:00 and 12:00. Build a timeline from it: first failed check, confirmation from further locations, recovery, total duration. Add the affected check locations. Then draft a post-mortem with the sections Timeline, Impact, Cause and Actions. Leave Cause open if the data does not support one.What you get: A post-mortem with evidenced timestamps instead of recollections. That last sentence matters: invented root causes cost trust.
Tools: list_incidents, check_history, monitor_status
Pull the incidents from the last 30 days and isolate the short ones, under five minutes. For the three most frequent monitors, pull the check history around those timestamps and look for a pattern: did several check locations see the failure, or always the same one? Does the time of day repeat? Does it coincide with a maintenance window? Per monitor, tell me whether this looks like a real outage or like noise, and what I would change in the configuration. If the data does not support a call, say so.What you get: The evidence you need to fight alert fatigue before your team starts clicking notifications away.
Tools: uptime_summary, list_incidents
Pull the uptime figures for monitor [ID] for day, month and year, plus the average response times and this month's incidents. Translate the numbers into client language: what does 99.95 percent in a month mean in actual minutes? Write three paragraphs for the monthly report: result, how it sits in the yearly trend, what we are watching next month. No jargon without explanation, no sugar-coating.What you get: Three paragraphs the client understands, without anyone on the team translating them afterwards.
Tools: uptime_summary, list_incidents
We promised deinkunde.com 99.9 percent monthly uptime. Pull the actual figures for monitor [ID] and this month's incidents. Work out how much downtime the promise allowed and how much of it we used. If we went over: write an honest explanation plus two concrete actions. If we stayed under: write the single sentence I use to place that in the meeting without bragging.What you get: Both conversations prepared. The second case will happen more often and go unused more often.
Tools: uptime_summary, list_incidents, list_monitors
For every monitor belonging to deinkunde.com, pull the uptime figures and the incidents of the last three months. Build the quarterly meeting document: a table with service, uptime, incident count and longest outage. Then three sentences on the trend against the previous quarter, and one paragraph on what we actually did this quarter, evidenced by the data. Write it so I can drop it on a slide without reworking it.What you get: The quarterly slide that otherwise costs two hours of copy and paste.
Tools: list_incidents, uptime_summary, check_history
Pull the incidents of the last 90 days for the monitors of deinkunde.com, plus the uptime figures across the year. Find patterns: do incidents cluster at certain hours, around certain services, in certain weeks? Build the case for a wider scope of care from it: observation, consequence for the client, proposal. Exactly three points, each backed by a number. If the data shows no pattern, say so and propose nothing.What you get: An upsell conversation standing on measurements instead of on a feeling. That last sentence protects your credibility.
These prompts are templates. Three rules make them yours.
The prompts are meant to be edited. Swap the domain, name your own selectors, change the window, and keep the last line that tells the assistant what to do when the data does not support an answer. If the machine should do the setup work too, the same API drives client onboarding by API.
- Say what should come out the other end, so the output format lives in the prompt instead of in your cleanup afterwards.
- Draw the boundary yourself, so a narrow question returns a short answer you can use, not a long one you have to read.
- Allow for not knowing, so an SLA report never carries a confident guess into a client meeting.

Name the shape you want back — table, ticket, client email, three paragraphs. Almost every prompt here ends with a format instruction.
"All selectors" is not an instruction. Name the selectors, the domains, the window. A tight prompt returns a short, usable answer.
An invented root cause in a post-mortem costs more trust than an open one.
Frequently Asked Questions
The Prompt Library is a public collection of twenty ready-to-run prompts for agencies and MSPs. Each prompt instructs an AI assistant to execute real checks through the Uptimeify MCP server: DNS, SPF, DKIM, DMARC, DNSBL, TLS, HTTP headers, redirects, reachability, plus your own monitors, incidents and uptime figures. The prompts are made to be copied and freely adapted.
The first ten. They inspect everything visible from the outside and need no sign-in: mail records, domain and certificate deadlines, DNS propagation, the HTTPS chain, security headers, reachability and response times. Prompts 11 to 20 work with your own monitors, incidents and uptime figures and need the one-time connection to your account. The filter bar lets you show exactly the group you want.
Point it at the endpoint and add the header. Leave the header out entirely if you only need the ten prompts that run without an account.
{
"mcpServers": {
"uptimeify": {
"url": "https://uptimeify.io/mcp",
"headers": { "Authorization": "Bearer wsm_your_token" }
}
}
}
Create the token under Settings, API tokens. Leave the customer field empty and it sees every customer in your organization; pick a customer and it is scoped to that one. The token is shown once, at creation.
Yes. Every check behind these prompts also exists as a browser tool, so you can verify a result by hand or hand one to a colleague who does not use an assistant — SPF checker, DKIM validator, DMARC analyzer, MX lookup, DNSBL check, SSL certificate checker, domain expiry checker, DNS propagation checker, redirect checker, HSTS tester and HTTP header checker. For the reporting prompts the SLA uptime calculator and the error budget calculator do the arithmetic the client will ask about. The full set is on the tools overview.
No. Every tool on this path is read-only. There is no route through which an assistant could create, edit or delete monitors, customers, status pages or settings, and the consent screen says exactly that. A call outside the permitted range is rejected. If you want to automate write operations, use the REST API with a regular API token.
Any client that connects to remote MCP servers over Streamable HTTP. Clients with OAuth support connect without a hand-made token, clients with custom headers use an API token, and clients that only speak stdio bridge through mcp-remote. The prompts themselves are tied to no vendor. They are plain text.
The checks run on European Uptimeify infrastructure, with monitoring locations in Germany, Finland, Italy, Poland, Czech Republic and Switzerland. Uptimeify is built and hosted in Frankfurt, Germany, with no US sub-processors. That reduces the risk around third-country transfers and takes an entire discussion off the table in B2B and public-sector pitches. The service providers involved are listed in the subprocessor overview.
Ready to put your assistant to work?
Ten of these prompts run before you even have an account. The other ten show you what your portfolio actually did over the last ninety days. Connect Uptimeify once, copy the first prompt, let it run.