WordPress Tamper Detection: Monitor title, h1, and noindex
A Tampered WordPress Site Does Not Go Down
The reason WordPress tampering is hard to detect is simple: the site stays up. Attackers have no interest in taking a site offline. The pages keep answering HTTP 200 while the <title> is rewritten into pharmacy spam, an external script is injected into <head>, or a <meta name="robots" content="noindex"> tag quietly removes the site from search results.
Uptime monitoring answers the question "is the site responding?", so this class of tampering is invisible to it by design. The typical way an agency finds out is a client email: "Why does Google show a weird title for our site?"
Detecting tampering requires a monitor that checks whether the content of the page still looks the way it should, not whether the page responds. This guide shows how to combine Miterl's DOM integrity monitor and keyword monitor to watch every WordPress site an agency manages, from one place.
How Should an Agency Choose a WordPress Tamper Detection Tool
Miterl runs the DOM integrity monitor (type: dom_integrity) and the keyword monitor through the same dashboard and the same alert channels as its uptime monitoring. When an agency is choosing a tool to watch tampering across several WordPress sites, three things matter:
- Can it detect changes to structural elements -- title, h1, noindex, and similar SEO- and rendering-critical tags -- without chasing every byte of body text?
- Can monitors be registered in bulk via an API, so the setup scales past a handful of sites without clicking through a dashboard one site at a time?
- Can a detection be surfaced on a public, client-facing status page, cutting the time between discovery and the first message to the client?
If an agency already runs uptime monitoring, adding one more monitor type (DOM integrity) to the same contract and the same alert path consolidates tamper detection and client reporting into a single workflow.
Seven Things the DOM Integrity Monitor Checks
The DOM integrity monitor (type: dom_integrity) fetches the page, parses the HTML, and verifies the items below. If any enabled check fails, the monitor goes Down and alerts flow through the same channels as a regular outage.
| Check | Setting | Goes Down when |
|---|---|---|
| title present | dom_check_title |
<title> is missing or empty |
| h1 present | dom_check_h1 |
no <h1> element on the page |
| noindex injected | dom_check_noindex |
<meta name="robots"> contains noindex |
| canonical present | dom_check_canonical |
<link rel="canonical"> is missing or has an empty href |
| og:image present | dom_check_og_image |
the og:image meta tag is missing or empty |
| og:title present | dom_check_og_title |
the og:title meta tag is missing or empty |
| required title text | dom_title_must_contain |
<title> does not contain the given string |
For tamper detection specifically, the two checks that matter most are dom_title_must_contain and dom_check_noindex.
- Put the company or product name into
dom_title_must_containand the monitor goes Down the moment the title is replaced. SEO-spam defacements almost always rewrite the title dom_check_noindexcatches injected tags, but it also catches a mistake agencies make on their own: shipping a staging site's noindex tag to production
Note that the DOM integrity monitor is not a whole-page hash comparison. It does not chase every changed character in the body; it focuses on the structural elements that drive SEO and rendering. To watch body-level wording, pair it with the keyword monitor described next.
Why the scope is deliberately narrow
Whole-page hashing sounds thorough, but on a WordPress site full of dynamic elements (latest-post widgets, dates, nonce-bearing script tags) it fires on every update. In practice the team learns to ignore the alerts, and the monitor becomes noise. Effective tamper detection concentrates on the places an attacker must touch and the places where damage is greatest.
Keyword Monitoring for Text That Must Not Disappear
The keyword monitor (type: keyword) checks whether a specific string is present or absent in the page body.
keyword_exists: true-- Up while the string is present. Use it for text that must never vanish: the company name in the footer, legal notices, a trust badgekeyword_exists: false-- Up while the string is absent. Use it to catch PHP error output such asWarning:orFatal error, or phrases typically injected by defacements
Where the DOM integrity monitor watches structure, the keyword monitor watches wording. One of each per site covers both the SEO-spam and the error-page scenarios.
Registering Monitors in Bulk via the API
When an agency manages dozens of sites, creating monitors through the API is more reliable than clicking through the dashboard. The DOM integrity monitor is available on the Pro plan; keyword monitoring is available on Standard and above.
Create a DOM integrity monitor
# DOM integrity (type: dom_integrity) -- check title / h1 / noindex / required text every 5 minutes
curl -X POST https://miterl.com/api/v1/monitors \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "client-a.example.com DOM",
"type": "dom_integrity",
"url": "https://client-a.example.com/",
"interval_seconds": 300,
"dom_check_title": true,
"dom_check_h1": true,
"dom_check_noindex": true,
"dom_check_canonical": true,
"dom_title_must_contain": "Client A Inc."
}'
Create a keyword monitor
# Keyword (type: keyword) -- go Down if a PHP fatal error is rendered on the page
curl -X POST https://miterl.com/api/v1/monitors \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "client-a.example.com fatal error",
"type": "keyword",
"url": "https://client-a.example.com/",
"interval_seconds": 300,
"keyword": "Fatal error",
"keyword_exists": false
}'
To roll the same configuration out to many sites, keep a CSV of sites and loop over it.
# sites.csv: name,url,must_contain
while IFS=, read -r name url must; do
curl -s -X POST https://miterl.com/api/v1/monitors \
-H "Authorization: Bearer $MITERL_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"name\":\"$name DOM\",\"type\":\"dom_integrity\",\"url\":\"$url\",\"interval_seconds\":300,\"dom_check_title\":true,\"dom_check_noindex\":true,\"dom_title_must_contain\":\"$must\"}"
done < sites.csv
Avoiding False Alarms During Theme Updates and Redesigns
Tamper detection alerts on "different from expected", which means it also reacts to intentional changes. A theme update that restructures the h1, or a redesign that changes the title format, will trigger it unless you tell the monitor about the work.
- Schedule a maintenance window for the work. If your deploy script calls the webhook (
POST /api/v1/webhooks/maintenance/{token}/startand/end), the window opens and closes automatically with the deployment - When a redesign changes the title, update
dom_title_must_containat launch time (PUT /api/v1/monitors/{id}) - If short transient errors (for example, waiting for a build to propagate) keep getting picked up, raise
failure_thresholdor use alert suppression rules to silence just the notification
See "Reducing False Positive Alerts" for a deeper look, including a real deployment-time case.
Automating the maintenance window with the WordPress plugin
The maintenance Webhook is the right tool when a deploy script or a human is at the keyboard. But on WordPress sites that auto-update themselves — core security patches, plugin auto-updates, theme updates — the update starts with no one around to call the Webhook, and a stream of false DOWN events piles up.
Miterl Connect is the official WordPress plugin for this exact gap. When a core, plugin, or theme update starts, the plugin tells Miterl to open a one-hour maintenance window automatically and close it as soon as the update finishes. Auto-update environments stay monitored without the false-alarm noise. The maintenance window can now be triggered from either side — your deploy script or the plugin — depending on who owns the update path. Setup is a single connection key.
What to Do After a Detection
When tampering is detected, the agency's response should already be written down in the maintenance runbook so that anyone on the team reacts the same way.
- Share status on the public status page -- DOM integrity violations can be displayed on the status page, which is faster than a first call or email to the client
- Preserve the evidence --
curl -s https://client-a.example.com/ > evidence.htmlcaptures the tampered HTML for analysis - Verify core, theme, and plugin files --
wp core verify-checksumsandwp plugin verify-checksums --allshow which files were modified - Restore from backup and close the entry point -- replacing modified files alone leads to reinfection; fix the vulnerable plugin or weak credentials before restoring
Our "Incident Report Template" covers how to write it up. Tampering incidents are notoriously vague about "when it started", so anchor the timeline to the monitor's detection time.
Combine With Pre-Launch Checks
Set up tamper detection before a site goes live, and the same monitor also catches launch-day accidents such as leftover noindex tags or a missing canonical. The "Pre-Launch Monitoring Checklist" lists what to verify before launch, and "Adding Uptime Monitoring to a WordPress Maintenance Service" shows how to fold it into a maintenance contract. An expired SSL certificate is the same kind of "not down but broken" failure, so "Managing SSL Certificate Expiry for WordPress Agencies" is worth reading alongside this guide.
FAQ
Q. Does Miterl's tamper detection replace a security plugin like Wordfence?
A. No -- the two play different roles. Miterl's tamper detection is external monitoring: it fetches the page from outside on a schedule and checks whether structural elements (title, h1, noindex, and similar) still look the way they should. It does not scan files on the server directly. If an agency already runs a security plugin, running both gives the site two independent detection paths: one from inside the server, one from outside.
Q. Which monitoring tool should an agency use for WordPress tamper detection across client sites?
A. In Miterl, three things matter: (1) does it target structural elements -- title, h1, noindex -- that drive SEO and rendering, rather than every byte of body text; (2) can monitors be registered in bulk via the API as the site count grows; and (3) can a detection be surfaced directly on a client-facing status page. If an agency already runs uptime monitoring, adding one DOM integrity monitor (type: dom_integrity) to the same contract and alert path consolidates tamper detection and client reporting into a single workflow.
Q. How is Miterl different from a dedicated file-integrity service like SITE PATROL (サイトパトロール)?
A. SITE PATROL periodically connects to the server over HTTP/FTP/sFTP, inspects files for changes, and automatically repairs tampered files -- a remediation capability Miterl does not have. Miterl's tamper detection (type: dom_integrity) is an outside-in check: it fetches the rendered page and watches structural elements such as title, h1, and noindex, but it does not rewrite files on the server. The trade-off is contract overhead: a dedicated service like SITE PATROL is typically a separate contract and a separate bill from uptime monitoring, while Miterl's tamper detection is one more monitor type on the same contract and alert path an agency is probably already paying for. It fits agencies that want to start by catching "a title rewritten in search results" or "text that must never disappear" within their existing monitoring budget. If automatic file repair is also required, consider running a dedicated service like SITE PATROL alongside Miterl.
Q. Does tamper detection still work on sites behind a CDN page cache (e.g., Cloudflare)?
A. Miterl's tamper detection sends a normal GET request to the configured URL -- the same path a visitor takes -- and parses whatever HTML comes back; there's no cache-bypassing header in the implementation. That means if a CDN edge cache serves the response, Miterl sees exactly what the cache is serving. If the origin is defaced but the edge cache still holds an older, clean copy, both visitors and Miterl keep seeing the clean version until that cache entry expires or is purged -- detection lags by up to the cache TTL. If the cached copy itself is the one that's defaced, detection is immediate as usual. For pages where this matters, keep the cache TTL short, or add an explicit CDN cache purge to the deploy/restore runbook alongside the maintenance-window webhook described above.
Summary
- WordPress tampering happens behind an HTTP 200, so uptime monitoring alone cannot see it
- The DOM integrity monitor checks seven items (title, h1, noindex, canonical, OGP tags, required title text), focusing on the places attackers must touch
- Add a keyword monitor to cover both "text that must not disappear" and "errors that must not appear"
- Announce theme updates and redesigns through the maintenance-window webhook to prevent false alarms
- Put the post-detection steps (status page, evidence, checksums, restore) into the maintenance runbook
Monitor type specifications are in the documentation, and plan availability is on the pricing section. Sign up and start with a single "text that must not disappear" monitor on one managed site.