Pasteboard Viewer: inspecting macOS pasteboards before your app ships

What Pasteboard Viewer solves for AppKit and UIKit developers

When an app writes to the pasteboard, it rarely writes one thing. It writes a set of types: plain text, RTF, an image, a file URL list, a custom UTI. What you intended and what actually landed are often different, and the pasteboard gives no error when a type is missing. Pasteboard Viewer exists to close that gap. The README describes it as a developer utility that lets you inspect the various system pasteboards, useful to ensure your app is putting the correct data on NSPasteboard or UIPasteboard.

The audience is narrow and the project says so: this is not a clipboard manager, and if you are not a programmer you probably do not want it. That sentence does most of the positioning work. Someone who wants to paste yesterday's copied text is in the wrong repository. Someone who just spent an afternoon wondering why a rich text paste loses its formatting is exactly the target user.

How the inspection works: live refresh, type list, Quick Look

The mechanism is a live view over the system pasteboards. The README states the app refreshes the pasteboard contents live and can preview text, RTF, images, and anything that has a Quick Look preview. So the loop is: copy in your own app, switch to the viewer window, watch the type list and previews update without a manual reload step.

Two behaviours matter more than they first appear. First, the app hides obsolete system pasteboard types that have modern equivalents, and the README names CorePasteboardFlavorType, NSStringPboardType, and NSFilenamesPboardType. A raw dump of an NSPasteboard is noisy precisely because of these legacy aliases, and filtering them is a deliberate editorial choice: you see the modern type, not the compatibility shim. Second, you can right-click an item in the sidebar to copy the type identifier, which is the small convenience that turns the tool from a viewer into something you use mid-debug.

Navigation is keyboard-driven: the README says the up and down arrow keys switch between pasteboard items. On macOS the window can be pinned with "Stay in Front" in the Window menu, which matters when you are copying from another app and do not want the viewer to fall behind it. The repository is a Swift project with an Xcode project file and a SwiftLint configuration, and the topics list SwiftUI and NSPasteboard, so the UI layer is SwiftUI over AppKit pasteboard APIs.

Installing Pasteboard Viewer and inspecting your first pasteboard write

There is no package manager step here. The README points to the App Store as the primary download, and the current release requires a minimum of macOS 26, iOS 26, or visionOS 26. If your machine is older, the README lists direct downloads for macOS 15, 14, 13, 12, 11, and 10.15, each tied to a specific older version of the app. Those links are the install path; the repository itself ships an Xcode project rather than a build script or package manifest, so there is nothing to compile from the README alone.

For machines that cannot reach the App Store, there is a separate non-App Store build. The README says that version will not receive automatic updates and that it is updated once a year; at the time of the 2.12.0 release the linked archive is Pasteboard-Viewer-2.12.0 and targets macOS 26 or later.

Once installed, the workflow is copy, look, compare. Write something to the pasteboard from the app you are debugging, then read the type list in the sidebar. If you need the identifier for a type, right-click it in the sidebar to copy it, as the README describes. The README does not include a code sample for writing to the pasteboard, so there is no snippet to reproduce here: the first real use is simply to run your own app's copy action with the viewer open and compare the types it lists against the types you declared.

Where Pasteboard Viewer stops being the right tool

The clearest limitation is stated by the project itself: it is not a clipboard manager. There is no history, no search across past copies, no pinning. If you close the window, the record is gone; the pasteboard itself only holds what was last written. Anyone evaluating this as a replacement for a clipboard history utility will be disappointed, and the README pre-empts that by telling non-programmers they probably do not want the app.

The second limitation is platform. Despite the iOS and visionOS minimums in the README, the repository is described as inspecting the system pasteboards on macOS, the topics are macOS-centric, and the App Store listings exist for more than one platform. The README's own instructions for the always-on-top window are explicitly macOS ("On macOS, you can make the window always stay in front"), and the older-version download list is macOS only. Treat the non-macOS coverage as something to confirm on the App Store page rather than assume from the version requirements.

The third constraint is versioning. The current build requires macOS 26, which is a recent floor. If you are on an older OS you are downloading a frozen older release, and the non-App Store channel is explicitly a once-a-year update with no automatic updates. For a debugging tool that tracks OS pasteboard behaviour, that lag is a real cost.

Pasteboard Viewer versus a general clipboard manager

The natural alternative is a clipboard manager such as Maccy or Paste, and the difference is not a feature gap so much as a different object of study. A clipboard manager treats the pasteboard as a stream of user content: it captures what you copied, keeps a history, and lets you paste it again later. Pasteboard Viewer treats the pasteboard as a data structure: it shows the types currently on it, what each type contains, and how it renders.

That distinction decides the tool. If your problem is "I copied something ten minutes ago and lost it", a clipboard manager solves it and Pasteboard Viewer does not. If your problem is "my app declares RTF and plain text but the receiving app only sees plain text", a clipboard manager shows you the text it captured and tells you nothing about the missing type. The filtering behaviour is another divergence: a clipboard manager wants to preserve everything it can, while Pasteboard Viewer deliberately hides obsolete types like NSStringPboardType so the modern equivalent is not buried.

For cross-platform work, note that the related searches include clipboard viewers for Windows. Pasteboard Viewer is not that. It is an AppKit and UIKit inspection tool, and the pasteboard model it exposes is Apple's.

Licence, release cadence, and what upgrading costs you

The repository is MIT licensed, which is permissive and places few obligations on anyone reading or reusing the source. The practical distribution path, however, is the App Store, and the README also offers a non-App Store zip. Those two channels have different maintenance characteristics, and that is the upgrade cost to weigh: the App Store build updates automatically, while the README states the non-App Store build will not receive automatic updates and is updated once a year.

Release history in the repository shows an uneven rhythm rather than a steady train: v2.12.0 on 2026-03-30, v2.11.0 on 2025-09-13, and v2.10.1 on 2025-05-05. The last push to the repository was on 2026-03-30, roughly six months before this writing. That is recent enough that the project is not dormant, but the gaps between releases are measured in months, so do not expect a fix for a pasteboard edge case to land the same week you report it. The macOS 26 floor in the current release also means an OS upgrade is effectively an app upgrade; if you are pinned to an older macOS, you are pinned to an older build from the README's list. Nothing here is a legal opinion; read the MIT text in the repository if licence terms matter to your use.

Editorial conclusion

Adopt Pasteboard Viewer if you write or debug code that puts data on NSPasteboard or UIPasteboard and need to see the full type list rather than a rendered preview. Skip it if you want clipboard history, pinned snippets, or a non-macOS clipboard tool; the README states plainly that it is not a clipboard manager. Before relying on it, verify that your Mac meets the stated minimum (macOS 26 for the current release, with older builds linked for macOS 15 down to 10.15) and confirm whether you need the App Store build with automatic updates or the non-App Store build, which the README says is updated once a year and receives no automatic updates.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. sindresorhus/Pasteboard-Viewer on GitHub