iPhone Notes Screenshot API: What You Can Capture and How

Short answer: Apple does not document a public API that exports the rendered contents of another app’s Apple Note as an image. If you need a picture of what is on screen, use the iPhone screenshot action or the supported ScreenCaptureKit capture flow. If you need to share or export a note, use Notes’ Share interface. If you are building your own note-like app, share the data your app already owns through UIKit.

These are different operations: a screen capture produces pixels, while Notes sharing exports or shares note data. Neither UIKit’s share sheet nor ScreenCaptureKit gives an app general access to another app’s private Notes database.

1. Choose the result you actually need

Goal	Supported route	What you receive
Save exactly what is visible on the iPhone	Normal iPhone screenshot, or a supported ScreenCaptureKit flow in an app	A screen image
Send or export a note	Notes’ Share button and system activity view	Available sharing/export formats for that note
Share content from your own app	UIKit `UIActivityViewController`	The data your app supplies to the share sheet
Capture a website from a backend	ScreenshotNeo	PNG, JPEG, WebP, or PDF from one HTTP request

2. Taking a normal screenshot of a note

For a person using an iPhone, open the note and press the device’s side button and volume-up button together. The screenshot appears in Photos and can then be shared or marked up. This is the simplest way to capture a note as it appears on screen.

An app cannot silently automate that user gesture or read another app’s private Notes content. If your product needs a note image, ask the user to provide the image or use the Notes sharing/export workflow.

3. Programmatic screen capture with ScreenCaptureKit

ScreenCaptureKit is Apple’s framework for screen capture and streaming. SCScreenshotManager.captureImage returns one captured image frame using an SCContentFilter and an SCStreamConfiguration. It is a screen-frame API, not a Notes document export API.

Apple’s reviewed iOS sample uses the system content-sharing picker. The person chooses the full display or content inside the sample app, and the app receives a content filter before starting capture. The sample is marked preliminary and states an iOS 27-or-later requirement, so check the API’s availability and behavior against your deployment target before shipping.

Capture one selected frame

import ScreenCaptureKit
import CoreGraphics

@available(iOS 27.0, *)
func captureFrame(using contentFilter: SCContentFilter) async throws -> CGImage {
    let configuration = SCStreamConfiguration()
    configuration.width = 1170
    configuration.height = 2532
    configuration.pixelFormat = kCVPixelFormatType_32BGRA
    configuration.showsCursor = false

    return try await SCScreenshotManager.captureImage(
        contentFilter: contentFilter,
        configuration: configuration
    )
}

The filter must come from the supported picker/content-selection flow. Do not hard-code an assumption that the Notes app is always capturable, and do not treat this API as permission to inspect Notes data. Handle unavailable APIs with an availability check and provide a user-driven fallback.

Picker and capture flow

Present Apple’s system content-sharing picker.
Let the person choose the full display or an allowed in-app source.
Receive the resulting SCContentFilter.
Build a configuration for the required dimensions and pixel format.
Call SCScreenshotManager.captureImage for a single frame, or start a stream when you need continuous capture.
Encode the returned image and save it using your app’s normal file or Photos workflow.

The sample’s behavior around saving recordings to Photos and opening the standard share sheet is sample behavior. It does not guarantee that every Notes screen can be captured on every OS version, device, or configuration.

Notes has its own Share button. Apple’s interface guidance shows it opening the system activity view with actions such as sharing, copying, exporting, or adding markup. Choose this route when the recipient needs the note’s content rather than a pixel-perfect screen image.

Because the available activities depend on the note and the destination, the resulting file or representation can differ from a screenshot. This route also keeps the operation in the user-controlled Notes interface.

If your app stores the note-like content itself, pass the content you control to UIKit’s activity view controller. The activities shown depend on the data type you provide.

import UIKit

func presentShareSheet(from viewController: UIViewController,
                       text: String,
                       fileURL: URL? = nil) {
    var items: [Any] = [text]
    if let fileURL {
        items.append(fileURL)
    }

    let controller = UIActivityViewController(
        activityItems: items,
        applicationActivities: nil
    )

    if let popover = controller.popoverPresentationController {
        popover.sourceView = viewController.view
        popover.sourceRect = CGRect(
            x: viewController.view.bounds.midX,
            y: viewController.view.bounds.midY,
            width: 0,
            height: 0
        )
        popover.permittedArrowDirections = []
    }

    viewController.present(controller, animated: true)
}

This shares the string or file your app supplies. It does not retrieve a note from Apple Notes or bypass another app’s privacy boundary. See Apple’s UIActivityViewController documentation for the current API contract.

6. Edge cases and privacy constraints

Private Notes data: there is no documented public endpoint for reading another app’s private note database.
Capture selection: ScreenCaptureKit uses a content filter selected through Apple’s supported content-sharing flow.
OS availability: the reviewed iOS sample says iOS 27 or later and is preliminary. Gate the code with availability checks.
Screen versus document: a screenshot includes scroll position, zoom, keyboard state, and visible overlays; an export may preserve note content differently.
Permission and user intent: design capture as an explicit user action. Do not promise background or silent capture of Notes.
Large notes: a long note may require multiple screenshots or the Notes export path; a single screen frame only contains the selected visible frame.

7. Troubleshooting

Symptom	Likely cause	Fix
`SCScreenshotManager` is unavailable	The deployment target or runtime does not provide the API.	Use `#available`, verify the target OS, and offer a normal screenshot or sharing fallback.
No Notes content appears	The app expects a Notes document export from a screen-capture API.	Use Notes’ own Share/export interface; ScreenCaptureKit only captures a selected screen frame.
The picker does not return the expected source	The user selected a different display or app, or the source is not available.	Explain the selection step and validate the returned `SCContentFilter` before capture.
Image dimensions are wrong	The stream configuration does not match the desired pixel size or device scale.	Set width, height, and pixel format deliberately, then inspect the encoded image dimensions.
Share sheet has missing actions	UIKit activities depend on the item type and installed destinations.	Pass the correct text, file URL, or data representation and test on the target device.
Capture works in a sample but not in production	The sample is preliminary and may rely on OS-specific behavior.	Recheck current Apple documentation, availability annotations, entitlements, and the actual deployment target.

8. Performance, reliability, and cost

A one-frame capture is cheaper to process than a continuous stream: configure only the dimensions and pixel format you need, capture once, encode once, and release the image. Avoid unnecessarily large output sizes when a thumbnail is sufficient. For long notes, exporting note content may be more reliable than stitching many screen frames.

Reliability depends on user selection, OS availability, source visibility, and the current screen state. Treat capture as an operation that can fail or be cancelled. Report a clear retry path and preserve the user’s original content in your app.

ScreenCaptureKit and Notes sharing are platform APIs; this article does not assign a separate per-capture price to them. If your actual requirement is website screenshots from a server, a hosted API avoids maintaining browser infrastructure.

9. Or skip the browser setup

If you need website screenshots rather than an iPhone’s private Notes screen, ScreenshotNeo returns a clean PNG, JPEG, WebP, or PDF from one GET request. The API accepts the parameter names used by other screenshot services, and the API documentation lists the complete request options.

cURL

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

Python

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)

Node.js

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 failed: ${res.status}`);
const data = Buffer.from(await res.arrayBuffer());
require('fs').writeFileSync('shot.webp', data);

Before capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers. Options include full-page capture with lazy images loaded, CSS-selector element capture, dark mode, device presets or custom viewports, retina scale, PDF paper and page settings, custom CSS and JavaScript, clicks, selector or network-idle waits, blocked ads and resources, headers, cookies, user agents, Authorization, timezone, geolocation, transparent backgrounds, resizing, TTL caching, signed image links, asynchronous jobs with signed webhooks, bulk capture for up to 100 URLs per call, and a usage API.

It also provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The Free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.

10. FAQ

Can an iOS app read Apple Notes and turn a note into PNG?

There is no documented public Notes-specific endpoint for that. Ask the user to export or share the note, or capture a user-selected screen frame where supported.

Does ScreenCaptureKit capture only Apple’s Notes app?

No. It is a general screen capture and streaming framework whose source is selected through a content filter and the system picker.

No. UIActivityViewController shares the data your app supplies; it does not retrieve private data from another app.

What should I use for a website screenshot backend?

Use ScreenshotNeo when you want a hosted HTTP API, clean captures, usage-based billing that excludes failed or blocked pages, and MCP tools for AI agents.