How Microsoft AI Screen Capture Works for Developers

Direct answer: Microsoft Recall is an opt-in Windows feature that periodically saves snapshots of the active screen when content changes, stores them locally, and analyzes them on the PC. Local OCR, screen segmentation, image recognition and contextual indexing make those snapshots searchable with natural-language clues. Developers integrate with Recall mainly by adding UserActivity deep links so a result can reopen the original app state, and by excluding sensitive windows with SetWindowDisplayAffinity.

Recall is not a screenshot API that your app calls to read the snapshot database. Windows owns capture, storage, indexing and user consent. Your app supplies relaunch metadata and declares which windows must not appear in Recall or other capture tools.

1. What Recall captures and how it processes snapshots

After the user enables Settings > Privacy & security > Recall & snapshots > Save snapshots, Windows saves a snapshot every few seconds and when the active window’s content changes. Microsoft describes this as: “If you opt in to the feature, then as you use your PC, a snapshot of your active screen will be saved every few seconds and when the content of your active window changes.”

The processing pipeline is local:

Windows detects a screen change and records a snapshot.
On-device OCR extracts text.
Screen segmentation and image recognition identify visual regions and objects.
Contextual indexing connects text and visual information to searchable activity.
The user searches with natural-language clues and can select a result.
Your app can receive a deep link that restores the relevant document, page or state.

Click to Do can analyze a selected snapshot and offer actions such as copying recognized text or sending an image to an application that supports JPEG input. The exact actions depend on the selected content and installed apps.

Requirement	What developers need to know
Hardware	A Copilot+ PC based on Qualcomm, Intel or AMD hardware.
Windows	April 2025 Windows non-security preview update or later, according to the cited developer prerequisites.
Architecture	Arm64EC is listed as unsupported in the cited documentation.
User consent	The user must separately opt in to saving snapshots. Administrators cannot silently enable snapshot saving for an end user.
Languages	English, Simplified Chinese, French, German, Japanese and Spanish are listed as optimized languages. Content and storage limitations still apply.

For a development machine, verify the Windows servicing level, confirm that Recall is available, and test with a real user account that has enabled snapshot saving. Availability and behavior can change with Windows servicing updates, so date-stamp your setup documentation.

3. A practical integration sequence

Install your app on a supported Copilot+ PC.
Ask the user to enable Recall snapshot saving in Windows Settings; do not attempt to enable it programmatically.
Create UserActivity records containing deep links to the document, page or workflow state represented by an activity.
Apply capture protection to every window that can display credentials, payment data, health information, secrets or regulated content.
Test normal mode, private mode, remote desktop and any workflow that temporarily changes what the window displays.
Verify that selecting a Recall result returns the user to useful app state rather than merely opening the app home screen.

4. Launch Recall from an app

Windows exposes the ms-recall protocol URI. Calling it opens Recall and takes a snapshot of the screen, which is the default behavior when Recall is launched.

#include <windows.h>
#include <shellapi.h>

int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int) {
    auto result = ShellExecuteW(
        nullptr,
        L"open",
        L"ms-recall:",
        nullptr,
        nullptr,
        SW_SHOWNORMAL);

    return reinterpret_cast<INT_PTR>(result) > 32 ? 0 : 1;
}

Use this as an explicit user action, such as a “Review recent activity” command. The protocol launches the Windows experience; it does not grant your process access to Recall’s local snapshot store.

5. Make Recall results reopen the right app state

UserActivity is the relaunch surface. Store a deep link that identifies the source document, page or workflow state. When a user selects a Recall result, Windows can use that link to return to your app and continue where the activity occurred.

A robust deep link should contain a stable document identifier and enough state to restore the view without putting secrets in the URI. Resolve the link on your normal app activation path, check authorization again, and handle deleted or moved content gracefully.

// The URI is an example of an app-owned deep-link format.
// Register your app's protocol and create UserActivity metadata
// with the Windows UserActivity API in your app's activation flow.
var activityUri = new Uri(
    "myapp://work/item/8f2c1a?view=review&revision=42");

// On activation, resolve the item and restore the requested view.
if (activityUri.Scheme == "myapp" &&
    activityUri.Host == "work")
{
    var itemId = activityUri.AbsolutePath.Trim('/').Split('/')[1];
    var query = System.Web.HttpUtility.ParseQueryString(activityUri.Query);
    var view = query["view"] ?? "default";

    await OpenAuthorizedItemAsync(itemId, view);
}

The exact UserActivity registration API varies with the Windows app framework you use. Keep the important contract stable: an app-owned URI, a registered activation handler, authorization on activation and a fallback when the resource no longer exists.

6. Exclude sensitive windows from Recall and screen capture

SetWindowDisplayAffinity is the principal Windows control for capture protection. WDA_MONITOR keeps a window visible on a physical monitor but causes it to appear blank elsewhere. WDA_EXCLUDEFROMCAPTURE keeps the window out of Recall and other screenshot applications.

#include <windows.h>
#include <iostream>

bool ExcludeWindowFromCapture(HWND window) {
    return SetWindowDisplayAffinity(window, WDA_EXCLUDEFROMCAPTURE) != 0;
}

bool MakeWindowMonitorOnly(HWND window) {
    return SetWindowDisplayAffinity(window, WDA_MONITOR) != 0;
}

int main() {
    HWND window = GetConsoleWindow();
    if (!window) return 1;

    if (!ExcludeWindowFromCapture(window)) {
        std::cerr << "SetWindowDisplayAffinity failed: "
                  << GetLastError() << '\\n';
        return 1;
    }

    std::cout << "Capture exclusion enabled\\n";
    return 0;
}

Apply the affinity to the top-level window that actually renders the sensitive content. Reapply it when windows are recreated, and test every mode that can show the data. Microsoft specifically warns that clients without screen-capture protection can be saved by Recall; DRM content is not stored.

Choosing a protection mode

Mode	Use when	Result outside the monitor
`WDA_EXCLUDEFROMCAPTURE`	The window must not appear in Recall or screenshot applications.	Excluded from capture.
`WDA_MONITOR`	The user may view the window on the monitor, but copies or captures must not reveal it.	Window appears blank.

Protection is a window-level decision. A browser private mode, remote desktop client or sensitive workflow may need to change policy temporarily. Make that transition explicit and restore protection before sensitive content returns.

7. Privacy, security and enterprise policy

Recall is opt-in and users can pause, delete or disable snapshots.
Snapshots and associated contextual data are stored locally and encrypted.
Windows Hello confirmation is required when launching Recall or changing settings.
Microsoft states that snapshots and associated data are not shared with Microsoft or other users on the device.
Managed organizations can remove or disable Recall by policy until IT allows it.
Administrators can control whether users may enable Recall and configure snapshot and DLP policies, but cannot turn on snapshot saving for a user.

Enterprise integrations include a Recall DLP Provider API, browser activity APIs for website filtering, exported-snapshot decryption guidance and Click to Do interactions. These are separate surfaces with their own consent, identity and policy requirements.

8. Testing checklist for a Windows app

Supported Copilot+ hardware and the required Windows update are installed.
Snapshot saving is enabled by the signed-in test user.
Normal text and visual content can be found with natural-language searches.
A selected result reopens the correct document and view through UserActivity.
Credentials, payment fields, health data and secrets are excluded or blanked.
Protection is applied after window recreation and during navigation.
Private browsing, remote desktop and DRM workflows behave as intended.
Deleted or unauthorized documents fail safely when a deep link is opened.
Organization policy changes are handled without assuming that snapshot saving is enabled.

9. Troubleshooting

Symptom	Likely cause	Fix
Recall is missing	Unsupported hardware, Windows build or organization policy.	Verify the Copilot+ PC, April 2025 update or later, device availability and IT policy.
No snapshots appear	The user has not opted in to Save snapshots, or has paused/disabled them.	Check Recall settings with the user. An administrator cannot silently enable saving.
Your app never reopens from a result	No valid UserActivity deep link or activation handler.	Store a stable app URI, register activation, resolve authorization and provide a missing-resource fallback.
Sensitive content appears in a capture	Affinity was applied to the wrong window, applied too late or removed after recreation.	Set affinity on the top-level content window, reapply after recreation and test each sensitive mode.
The protected window is blank on screen	`WDA_MONITOR` was selected where exclusion was intended.	Use `WDA_EXCLUDEFROMCAPTURE` when the window must remain out of Recall and capture tools.
Search quality varies by language	The content language is outside the optimized language list or has storage/content limits.	Test the languages your users need and document the supported behavior.
Remote desktop behavior differs	Capture protection and display affinity interact with the client and mode.	Test the actual remote desktop client and choose a policy for each workflow.

10. Performance, reliability and cost considerations

Recall’s OCR and contextual indexing run locally on the Copilot+ PC, so your app does not need to upload screenshots or operate a screenshot-processing service. The trade-off is device and Windows-version dependence: hardware capability, servicing updates, language and storage limits affect behavior.

UserActivity links improve reliability because they let your app reconstruct the source state instead of depending on a screenshot alone. Keep identifiers stable, avoid putting credentials in links, and verify access every time a link is opened.

For capture protection, favor a small, explicit policy surface: mark only windows that can contain sensitive data, reapply the setting when handles change, and include automated checks in your release process. Recall itself has no developer API charge in the supplied documentation; organizational cost is mainly the supported Copilot+ hardware, Windows management and engineering work needed to integrate and test it.

11. When you need an actual screenshot API

Recall is designed for a user’s local activity history. If your product needs a deterministic image or PDF of a public URL, a server-side screenshot API is a better fit. ScreenshotNeo is the first service to try: it removes consent banners, newsletter popups and chat widgets before capture, bills only clean shots, and has the lowest paid plan listed here.

Or skip the browser setup

One GET request returns a PNG, JPEG, WebP or PDF. See the ScreenshotNeo API documentation for all 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)
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}`);

Cookie banners, popups and chat widgets are removed before the shot. Bot checks, blank pages and failed loads are never billed, and response headers identify the page verdict and whether it was billed. An MCP server lets Claude, Cursor and other MCP clients 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. Create a free ScreenshotNeo account.

12. FAQ

Does Recall continuously record video?

No. It saves periodic snapshots and additional snapshots when the active window content changes.

Can my app read Recall’s snapshot database?

The integration model described by Microsoft uses UserActivity relaunch metadata and window capture protection; it does not give your app ownership of the snapshot store.

Can an administrator enable snapshots for everyone?

No. Administrators can govern availability and policy, but users must opt in to saving snapshots.

Does `WDA_EXCLUDEFROMCAPTURE` protect a child control?

Apply display affinity to the top-level window that renders the sensitive content and verify the result in the capture paths you support.

Is a Copilot+ PC required to develop the integration?

The cited Microsoft prerequisites require a Copilot+ PC for Recall development and use, along with the specified Windows servicing level.