How to Automatically Take Screenshots at Scheduled Times

To automatically take screenshots at scheduled times, pair a recurring trigger with a capture method that can access your target. For a local desktop, schedule a compatible screenshot script or program on the computer. For a public web page, schedule a URL capture command or API request. These are different jobs: a hosted page renderer captures a URL, not your private desktop.

Start by deciding what the screenshot must show:

Desktop, window, or region: use software running on the computer and check that it can access the right user session and display.
Public website: use a browser-based capture utility or screenshot API, then schedule its command or request.

A recurring schedule is not complete until a real run creates an image at the expected path and shows the intended screen or page. Also check what happens when the computer is asleep, locked, logged out, or offline.

1. Choose the capture target and schedule

Write down the target, frequency, time zone, output location, and how long to retain images. Decide whether missed runs should be skipped or caught up later. A capture at 9:00 a.m. local time on one machine may not match a UTC schedule in a cloud service.

Need	Suitable approach	Key constraint
Visible desktop or app window	Local capture utility or script plus OS scheduler	Requires a usable and permitted desktop session
Public page by URL	URL renderer or screenshot API plus scheduler	Captures a rendered URL, not a private desktop
One screenshot after a delay	Capture utility timer	A delay is not a repeating schedule

2. Schedule a desktop screenshot on Windows

Windows Task Scheduler can launch a program or script on minute, hourly, daily, weekly, monthly, startup, logon, or idle triggers. The scheduler starts the action; it does not guarantee that every capture tool can see the intended desktop in every login or lock state. See Microsoft’s schtasks create documentation.

Prepare a capture command

Install or choose a screenshot utility that supports the screen, window, or region you need. Put its executable and output folder at stable paths. The scheduler needs an actual capture command; the following example uses a placeholder executable and arguments because the exact command depends on the utility you select:

"C:\Tools\CaptureApp\capture.exe" --screen 1 --output "C:\Captures\desktop.png"

Replace the executable and flags with those documented by your capture tool. To preserve a history instead of overwriting one file, have a script generate a filename with the date and time, for example desktop-2026-10-04-0900.png.

Create a recurring task

For an hourly run, open Command Prompt and register the capture command. Keep the command path quoted if it contains spaces:

schtasks /create /sc hourly /mo 1 /st 09:00 /tn "Scheduled Desktop Screenshot" /tr "C:\Tools\CaptureApp\capture.exe --screen 1 --output C:\Captures\desktop.png"

This is a template: substitute a real capture program and its arguments. In Task Scheduler’s graphical interface, create a task, add a daily or weekly trigger (or another supported trigger), and set the action to start the capture program. Use its fully qualified path and set any required start-in folder. For a minute schedule through schtasks, use /sc minute /mo 15 for every 15 minutes. For a daily run, use /sc daily /st 09:00; for specified weekdays, use /sc weekly /d MON,WED,FRI /st 09:00.

Set the right session conditions

Choose an account with permission to run the capture utility and write to the destination folder.
If the utility needs an interactive desktop, configure the task to run only when the user is logged on. A noninteractive task may run without access to the visible desktop.
Test while the machine is in the conditions that matter: logged in, locked, logged out, on battery, or connected to multiple displays.
Prevent sleep if missing a capture matters, or use a machine and workflow that remain available. A desktop scheduler cannot capture while the computer is powered off.

Verify and manage the task

Run the task manually once from Task Scheduler, then inspect the output file and task history. Confirm that the file opens, has the expected screen and dimensions, and is written with a new timestamp on subsequent runs. To inspect a task from the command line:

schtasks /query /tn "Scheduled Desktop Screenshot" /v /fo list

Task Scheduler offers more trigger and condition settings than a simple command line. For example, you can choose weekdays, a monthly date, or a logon trigger. Review the task’s last-run result and action path whenever you change the capture program, account, or output folder.

3. Schedule screenshots on macOS

Apple’s built-in Screenshot panel opens with Shift + Command + 5 and can capture the entire screen, a window, or a selected region. It also offers a timer delay and a save location. Apple’s documentation describes that timer as a delay before capture, not as a repeating schedule. For recurring screenshots, use a separate automation mechanism and a capture command that is appropriate for your macOS version and privacy permissions. See Apple’s screenshot guide.

Before scheduling a macOS capture, grant the required screen-recording or accessibility permissions to the app or automation runner, if requested. A command that works in Terminal may behave differently when launched by a background scheduler because it may run under a different user or session. Run it from the intended scheduler context and inspect the resulting file.

For schedule control, use a recurring automation mechanism supported by your macOS setup, such as a launch agent, or a dedicated utility with recurring schedules. Configure the capture action, output path, and interval; then test a run and verify the permissions and login conditions. Apple’s Screenshot timer alone does not provide recurring scheduling.

4. Linux and other scheduled environments

On Linux, the scheduler and the screenshot tool must agree about the display session. A system service may not have access to an interactive graphical session, while a user-level job may have the needed display environment. Choose a scheduler already supported in your environment, such as a user timer or cron, and use a screenshot command documented for your desktop and display system.

No single Linux screenshot command works across every desktop, display server, and session configuration. Do not copy a command without checking whether it supports your X11 or Wayland session, screen selection, and permissions. Test from the same account and scheduler context that will run the recurring job.

5. Schedule screenshots of a public web page

For a page accessible by URL, let a renderer load the page and return an image. Then run the capture command on a recurring schedule. A Windows command-line capture utility can be used with Task Scheduler; a hosted screenshot API can be called by a scheduled script, cloud scheduler, or local scheduler. Browshot documents using its Windows command-line tool with Task Scheduler for scheduled URL captures. This workflow renders a website URL rather than reading the computer’s desktop.

Basic API request with cURL

This example captures a public URL with ScreenshotNeo and saves the response. See the ScreenshotNeo API documentation for request parameters and response details.

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

Put the command in a script, replace the URL and API key, and have the scheduler run the script. Avoid putting a real key in a shared script or a publicly readable command log; use your scheduler’s secret handling or a protected environment where available.

Python request

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()
with open("shot.webp", "wb") as f:
    f.write(r.content)

Install the dependency with python -m pip install requests. To keep history, generate a timestamped output name instead of overwriting shot.webp.

Node.js request

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}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

Save as an ES module or use a Node.js version with global fetch. As with Python, create a unique filename per scheduled run if you need an archive.

Connect the request to a recurring schedule

Make the request work manually and verify the saved image.
Put the working command in a script with an explicit working directory and output path.
Schedule the script at the required interval using the host’s scheduler.
Log the run time, response status, and saved path. Alert or inspect logs when a run fails.
Decide how to handle overlap: if a capture can take longer than the interval, prevent concurrent runs or choose a longer interval.

6. Choose capture settings for repeatable results

For web pages, the viewport, wait condition, and output format affect what each scheduled image shows. ScreenshotNeo supports full-page capture with lazy images loaded, element capture by CSS selector, dark mode, device presets and custom viewports, retina scale, PDF, custom CSS and JavaScript, clicks, hidden selectors, selector or delay or network-idle waits, request and resource blocking, headers, cookies, user agent, timezone, geolocation, transparent backgrounds, resizing, caching with a chosen TTL, signed links, async jobs with signed webhooks, bulk capture of up to 100 URLs per call, and a usage API and OpenAPI spec. Use only the settings needed for the page and keep them consistent across runs.

Setting	Use it when	Watch for
Viewport or device preset	You need a stable desktop or mobile layout	Responsive breakpoints can change what is visible
Wait for selector, delay, or network idle	Content renders after initial navigation	Long waits add time; network idle may not occur on pages with ongoing requests
Full page or element selector	You need a whole page or a specific component	Lazy content and sticky elements can affect the result
Cookies, headers, user agent, timezone, geolocation	The site varies by visitor context	Credentials and personal data need careful handling
Cache and TTL	Repeated identical captures can reuse a stored result	A cached result may not reflect the latest page state
Block requests or resource types	You want to omit ads, trackers, or heavy resources	Blocking a required script or stylesheet can change the page

7. Or skip the browser setup

For scheduled screenshots of public pages, ScreenshotNeo turns a URL into an image with one GET request. Put the request in a script and let your scheduler handle the timing:

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

ScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers report the page verdict and billing status. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Every feature is on every plan. See ScreenshotNeo and the API documentation.

Create a free account for 1,000 screenshots a month, with no card.

8. Reliability, performance, and cost

Uptime of the capture host: a local scheduler cannot run if the computer is off or asleep. A hosted scheduler avoids dependence on your personal desktop being awake, but still depends on network access and the chosen service.
Desktop session access: interactive capture can fail when logged out or locked. Validate the exact state; scheduler success only means the action started.
Timing: rendering time varies with page weight, network conditions, and wait settings. Allow enough time before the next scheduled run and avoid launching overlapping jobs.
Storage: timestamped images accumulate. Set a retention policy, compress or resize when suitable, and ensure the destination has free space.
Billing: estimate captures per month as URLs multiplied by runs per day and days in the month. For example, 10 URLs captured hourly for 30 days means about 7,200 requests before retries. Check the service’s current plan and how it treats cached or failed captures.
Consistency: use the same viewport, locale, authentication state, and wait rule when comparing images over time. Otherwise layout or personalization changes may look like site changes.

9. Troubleshooting scheduled screenshots

Symptom	Likely cause	Fix
No image appears	Wrong action path, working directory, permissions, or output folder	Run the action manually as the scheduled account; use absolute paths and check task history or logs.
Task runs but image is black, blank, or wrong display	The process cannot access the intended interactive session or selected screen	Test while logged in, confirm display selection and capture permissions, and configure the task for the required session.
Nothing runs while the computer is asleep	The operating system is not available to launch the task	Keep the host awake or move public URL captures to an always-available scheduler.
Screenshot is overwritten each time	Output filename is constant	Add a timestamp to the path or move each result into a dated folder.
Page is captured before it finishes rendering	Capture starts before dynamic content is ready	Wait for a stable selector or an appropriate delay; check the site for scripts that continue making requests.
Unexpected layout changes between runs	Viewport, cookies, locale, timezone, or personalization changed	Pin the rendering settings and provide stable cookies or headers when appropriate.
Request fails or returns an error	Invalid API key or URL, connectivity issue, timeout, or target-site restriction	Check the request parameters, network access, response status, and provider’s page-verdict or error headers.
Runs overlap or storage grows too fast	Capture duration exceeds interval or files are retained indefinitely	Prevent concurrent runs, increase the interval, and apply an archive or deletion policy.

10. FAQ

Can my Mac take screenshots automatically every hour?

Yes, with a recurring automation mechanism that invokes a suitable capture action. The built-in Screenshot panel’s timer is a one-time delay, so test the recurring runner’s permissions and session access.

Can I schedule screenshots while logged out?

A task may launch while logged out, but that does not guarantee access to a visible desktop. Check the capture program’s session requirements; for public pages, a URL renderer avoids relying on the local desktop.

Do I need a camera or capture card?

No. The usual workflow uses software, an operating system scheduler, or a URL screenshot service. Hardware capture equipment is for external video signals, not ordinary desktop or website screenshots.

Only when the capture request can reach the page and receives the required authentication context. Use supported cookies or headers carefully, and do not assume a public URL renderer can access a private desktop or account by itself.

How do I know a scheduled run really worked?

Check both the scheduler’s run result and the image itself. Confirm its timestamp, dimensions, destination, and visible content, then repeat the check at the next scheduled time.