How to send website screenshot change alerts to Discord

To send website screenshot change alerts to Discord, configure a website-change monitor to watch the page and send notifications to a Discord webhook. If you need an image in the alert, confirm that the monitor and the selected notification route support screenshot attachments, then verify it with a real test change. changedetection.io documents Discord notifications, browser-based fetching, and optional screenshots in notifications.

A practical setup has four parts: a page watch, a fetch method that can see the page content, a Discord webhook destination, and a screenshot setting supported by that notification route. A text alert with a link to the change history is a useful fallback if image delivery is unavailable.

1. Create a Discord webhook

1. In Discord, open the server and choose the channel that should receive alerts.
2. Create a webhook for that channel and copy its generated URL. Discord’s webhook guide describes creating the webhook, choosing its destination, and giving its URL to the sending service.
3. Keep the URL private. Treat it as a credential: anyone who obtains it may be able to post messages to its channel. Do not commit it to a repository, expose it in client-side code, or include it in a public issue.

You can check that the webhook accepts messages before connecting a monitor. Replace the placeholder with the private URL; this sends a test message to the configured channel.

curl -H 'Content-Type: application/json' \
  -d '{"content":"Website change monitor webhook test"}' \
  'YOUR_DISCORD_WEBHOOK_URL'

Discord webhook URLs contain a secret token. Avoid shell history or shared terminals when using a real URL; use a protected environment variable or secret store in automation.

2. Add the page to a monitor

Add the page URL as a watch in your monitoring service. With changedetection.io, choose the fetcher based on how the page gets its content:

• Request-based fetching: start here when the server response already contains the text or markup you want to monitor. It avoids running a full browser.
• Browser-based fetching: use this when content appears only after JavaScript runs, or when the page requires browser interaction. changedetection.io documents the html_webdriver backend, using Playwright or Puppeteer, and browser steps for interactive pages. Browser fetching needs more infrastructure and can take longer.

Do not assume the default fetcher can see content that a browser renders later. Check the captured page or extracted content in the monitor before relying on alerts.

3. Connect the monitor to Discord

Configure the monitor’s notification destination with the webhook URL, then use its notification test or trigger a controlled change. changedetection.io’s API documentation gives a Discord-style destination example in the form discord://webhook_id/webhook_token; follow the current setup instructions for the version and deployment you run rather than assuming all versions use the same input field.

For changedetection.io, the API documents notification configuration and a notification_screenshot option. Its README describes screenshot notifications. Screenshot inclusion depends on support by the configured notification URL, so confirm that the Discord route you selected supports it. A configured screenshot option alone does not prove that an image will arrive in Discord.

Choose what a useful notification should contain. A concise message linking to the watched page or change history is easier to scan; a screenshot adds visual context when attachment delivery works. Make at least one test that exercises the actual notification route.

4. Make the screenshots and alerts useful

• Watch a focused part of the page where possible. A large page may contain changing counters, rotating banners, timestamps, or recommendations unrelated to the change you care about. Use the monitor’s visual selection or content filtering where available, and review the resulting change history.
• Stabilize browser captures. Keep the browser/runtime, viewport, settings, and capture environment consistent. Playwright’s visual comparisons guidance notes that operating system, browser/runtime version, hardware, power source, and headless mode can affect screenshots.
• Hide volatile areas only when appropriate. Playwright documents applying styles to hide dynamic elements for visual comparisons. If the monitor supports equivalent CSS or selection controls, use them for regions that change on every load but are outside the scope of the alert. Do not hide a region whose changes you need to detect.
• Test meaningful changes. Change a page element you expect the monitor to track, then confirm the detected diff, Discord message, and screenshot behavior. Restore the page afterward if you used a temporary test change.
• Keep the alert actionable. Include enough context to identify the watch and a link to inspect the page or history. Do not put secrets or sensitive page contents into a channel whose audience should not see them.

Choosing a hosting and fetching approach

changedetection.io describes both a hosted subscription and self-hosting. A hosted service can reduce deployment and maintenance work; self-hosting gives you control over where the monitor runs and how it is operated, while leaving you responsible for updates and browser infrastructure when needed. Compare current plan details, fetcher availability, notification options, and deployment requirements in the project’s own documentation; the sources here do not establish current prices or which features every plan includes.

Choice	Fits when	Tradeoff
Hosted monitor	You prefer not to operate the monitoring deployment.	Check the provider’s current plan, data handling, browser-fetcher support, and notification capabilities.
Self-hosted monitor	You want to operate the deployment and control its environment.	You maintain the service and any required browser runtime; browser capture adds resources and possible rendering variability.
Request fetcher	The relevant content is present in the server response.	It may not see content created by client-side JavaScript or interactions.
Browser fetcher	The page needs JavaScript rendering or browser steps.	It uses more infrastructure and should run in a consistent environment for useful visual comparisons.
Text notification	A link and change summary are sufficient.	It does not provide the visual snapshot inside the alert.
Screenshot notification	Recipients need visual context in the message.	Attachment delivery depends on support in the selected notification route; verify it end to end.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. A single request captures a URL as an image; you can then connect the capture to your own change-detection and Discord notification workflow. The API call below captures a page; it does not itself monitor changes or send Discord alerts. See the ScreenshotNeo API documentation for request options.

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://stripe.com \
  -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000. Learn about ScreenshotNeo, then sign up for 1,000 free screenshots a month with no card.

Troubleshooting

Symptom	Likely cause	What to check
No alert arrives	The webhook URL, monitor destination, or notification rules are incorrect.	Send a direct webhook test, recheck the monitor’s destination format, and confirm notifications are enabled for the watch.
Text arrives, but there is no screenshot	The configured notification route may not support screenshot attachments, or screenshot notifications are not enabled.	Check the route’s support and the monitor’s screenshot setting, then test again with a real detected change.
The captured page is empty or incomplete	The page may need JavaScript rendering, more time, or interaction before content appears.	Inspect what the current fetcher receives; try the documented browser fetcher and required browser steps if appropriate.
Every check looks different	Dynamic content or a varying browser environment can change the visual result.	Keep the browser/runtime and viewport consistent; review the diff and hide unrelated volatile regions if the monitor allows it.
Alerts are noisy	The watch includes unrelated page regions or content that changes frequently.	Narrow the monitored area or filter content, then confirm that important changes still appear in the history.
Webhook test fails	The URL may be incomplete, revoked, or malformed, or the request body may not be valid JSON.	Copy the current webhook URL from Discord, use a JSON content type, and send a small valid payload.

Performance, reliability, and cost considerations

Request-based checks generally avoid the overhead of launching a browser, while browser-based checks provide rendered content and interaction support at the cost of browser infrastructure and additional capture work. Choose the lightest fetcher that can observe the content you need. A screenshot comparison can be less reliable when the environment varies or the page includes volatile content; stable settings and focused regions make changes easier to interpret.

The cited documentation does not establish a universal check interval, delivery latency, or alert guarantee. Set expectations using the current behavior and plan of the service you operate, and test the full path from page change to Discord message. For a hosted service, compare its current price and included capabilities directly; no current price comparison is established here. Self-hosting replaces a hosted subscription decision with your own deployment and maintenance costs.

FAQ

Can every Discord alert include a screenshot?

No. Screenshot attachment support depends on the monitor’s notification implementation and the chosen route. Verify the exact Discord configuration with a test change.

Do I need a browser fetcher for every page?

No. Use request-based fetching when the relevant content is already in the server response. Use browser-based fetching when rendering or interaction is needed to expose it.

Can I use a webhook from browser-side JavaScript?

A webhook URL is a posting credential. Keep it on a trusted server or in a protected secret store rather than exposing it in public client code.

Does ScreenshotNeo send change alerts to Discord by itself?

The ScreenshotNeo call shown here captures a page. You would still need a monitoring and notification workflow to detect changes and deliver Discord messages.