HeartbeatHocusFocusFilesMacHyperTile
Guide

usernoted, the daemon that hands you every notification

usernoted is the daemon behind every banner and Dock badge on macOS. Measured live: its database, 36 seconds of CPU a day, and the keychain prompt it triggers.

By Chethan Kumar S N · Updated

Of every lowercase name in Activity Monitor, usernoted is the one that touches you most often and gets thought about least. Every banner that slides in from the top right corner of the screen, every red badge on a Dock icon, every alert on the lock screen, and the stack of missed items you see when you click the clock: all of it passes through this one process. On the Mac measured for this page, a 10 core MacBook Pro running macOS 27.0.1 with 27 days of uptime, it has been running continuously since boot, process ID 1042, parented by launchd, and it has never exited once.

One detail separates it from most of the daemons in this series: it runs as you. Not root, not a reserved account like _windowserver or _coreaudiod, but your own user, the same one that owns your Home folder. That is not laziness in the design. Notifications are personal, they sit in your Notification Center, they sync through your iCloud account, and they are stored in a database inside your own Library folder. The daemon that manages them runs with exactly the identity they belong to.

Everything on this page was measured read only on that one Mac: the daemon’s manual entry, its launch configuration, the files it holds open, and a full day of its logs. Nothing was quit, killed or changed while measuring, and every command is at the end if you want to repeat any of it.

One sentence of manual, six megabytes of machinery

The manual page tells you what Apple thinks you need to know. usernoted(8), dated July 4 2018, is three sentences:

NAME usernoted - Notification Center daemon

DESCRIPTION: usernoted is a daemon that provides notification services on the system

There are no options for usernoted, and users should not run usernoted manually.

That is the entire entry. Behind it sits a 6,173,968 byte binary at /usr/sbin/usernoted, built for three architectures including an Intel slice that still ships, signed with Apple’s platform identifier 26, compiled September 24 2026. It is the second daemon in this series, after spindump, to ship with its own manual page at all, and the gap between the two is the whole story: a one line description in front of six megabytes of code, because the real specification is not prose, it is the list of doors.

Twelve doors, and the feature list they write

A daemon’s launch configuration lists the Mach services it answers, and for most daemons that list is two or three entries long. usernoted answers twelve. Read as a feature list, they describe the job better than the manual does:

The rest of the launch file is short and firm: KeepAlive true, RunAtLoad true, so it starts at login and is restarted instantly if it ever dies, and a spawn type of Interactive, the class launchd reserves for things that must answer a human’s expectations of immediacy. launchd’s own report for the job confirms the behaviour: one run since boot, 27 days ago, never exited, minimum runtime 10 seconds.

Apple’s developer documentation for the UserNotifications framework, which is the API apps actually call, never mentions the daemon that implements it. The framework page describes the two directions notifications come from, and the split is worth having in plain words: for local notifications, the app creates the notification content and specifies a condition, like a time or location, that triggers the delivery, while for remote notifications, your company’s server generates push notifications, and Apple Push Notification service handles the delivery of those notifications to the user’s devices. Local or remote, the last hop on a Mac is the same process.

The cost, measured honestly

Over 27 days and 5 hours of uptime, usernoted accumulated 16 minutes 20.69 seconds of processor time. That is about 36 seconds a day, four hundredths of one per cent of a single core, on a machine with ten of them. Its share of CPU in Activity Monitor reads 0.0 most of the time because most of the time there is nothing to deliver, and the process is waiting on one of those twelve doors.

Memory is the more interesting number, because it moves. Sampled three times over one afternoon, resident memory read 35,888 KB, then 33,488 KB, then 40,736 KB. The daemon breathes with traffic: notifications carry images and text, grouped notifications carry summaries, and the memory follows the work. There is no pressured exit configured for this job, no idle reclaim, which fits a service whose whole point is to still be there holding your unread list when you come back. It belongs on the running slow page’s list of daemons you can safely stop worrying about.

The state it keeps, and the walls around it

You cannot read usernoted’s database. That sentence is a finding, not a complaint, and it took three tools to establish.

The database is real and it is substantial. Listing the files the process holds open shows a SQLite trio inside your own Library, in the group container for the daemon: a main database of 958,464 bytes, a write ahead log of 3,876,952 bytes, and a shared memory file of 32,768 bytes. The log being four times the size of the database is the tell of a write heavy workload: every delivered, dismissed, and re delivered notification is a transaction, and SQLite batches them in the log before folding them in. Opening it read only from your own account returns authorization denied. Listing the group container with ls shows an empty folder, because the contents are protected from your own eyes, on your own machine, by the privacy framework. The same wall stands around the Biome stream it maintains at ~/Library/Biome/streams/restricted/Notification.Delivery, a 131,072 byte file the daemon both reads and writes: ls on that path returns Operation not permitted, full stop.

The open file list also shows what the daemon reads to do its job well, and this is where it gets charming. It holds open the localised name strings of Microsoft Outlook, Microsoft Excel, and Microsoft AutoUpdate, the en_GB InfoPlist.strings files from inside those app bundles, including one read out of a temporary install backup from an update in progress. It reads those files because a banner does not say com.microsoft.Outlook, it says Microsoft Outlook, in your language, and the only way to know that string is to open the app’s own localisation tables and look. The binary even carries a string for the pattern, infoPlistOriginated.

Three much bigger files are open for a different reason: a 28 MB language identification table, a 5 MB German tokeniser index, and a 36 MB copy of the Unicode common data. Together they let the daemon work out what language a notification is written in, which decides how it sorts, groups, and abbreviates. Your Mac keeps a linguist employed so your notifications can be alphabetised correctly.

And one small file connects this daemon to the prompt people actually search for: /private/var/db/mds/messages/501/se_SecurityMessages, 32,768 bytes, held open for reading. That is the message file belonging to the security subsystem, the machinery behind your keychain. It is the thread you pull next.

The keychain prompt, explained properly

Search for usernoted and the suggestions turn a corner the other daemon pages never hit: usernoted wants to use your confidential information. usernoted wants to use the login keychain. This is a prompt real people see, and it is genuinely unsettling the first time, because it names a process you never launched and mentions your keychain in the same breath.

Here is what is actually happening, and which parts of it are measured. The measured parts: the binary contains no keychain code of its own, no strings about keychains at all, because it does not implement keychain access, it links against the system’s security machinery, the same world the trustd page maps, where certificates get checked on the way to everywhere. It runs as your user, so code running inside it can request your keychain items the same way your own apps can. And it holds the security subsystem’s message file open, which is the plumbing connection between this process and that subsystem.

Not every daemon named in that prompt is a courier, though. assistantd, the Siri and dictation daemon, is the opposite case: its binary carries 51 keychain references of its own and it stores its session checkpoint and a device owner identifier in the login keychain by design, so when assistantd prompts, the item it wants is genuinely its.

The mechanism: some notifications are built from protected material. A Calendar alert for an event on an iCloud calendar, a Mail notification that needs the account’s credentials, an app whose notification content is stored as a secure item. When the code path that assembles one of those notifications runs, it runs inside usernoted, under your account, and when it touches the protected item, macOS does exactly what it is designed to do: it names the process making the access and asks you to vouch for it. The prompt says usernoted the way a delivery notification says the courier’s name. The parcel is someone else’s.

If you trust the app whose notification triggered it, and you can usually tell from the prompt’s details which item is involved, click Always Allow and it is finished. If it comes back in a loop, the keychain item’s access control list no longer includes the app that needs it, which happens after app updates and account migrations. The durable fix is removing and re adding the account in the offending app, which recreates the item with a correct access list. What you should not do is blanket deny and forget it, because you will have turned a courier away with the parcels still arriving.

A day in the log

The unified log for this process, over a full 24 hours, holds 28,605 lines, about one every three seconds, and an hour sampled in the afternoon held 601. Three refrains run through them.

The first is push. Lines like Delivering connectionStatusChange from apsd: NO appear in pairs whenever the push daemon reconnects, which is the daemon noticing the network changed and re establishing the channel remote notifications arrive on. If you have ever wondered how a notification finds your Mac the second Wi-Fi comes back, this line is that, working. The reconnection itself is apsd’s work, measured there holding one permanent line to Apple on port 5223 for the life of the machine.

The second is search. usernoted runs Spotlight queries. A sequence from the sampled hour reads: Handling group results: 1, then a query starting, then Found: 1 items. Delivered notifications are indexed so that searching for a name in Spotlight can surface the message that notified you about it, the same index the Spotlight page watches mds_stores build. The corespotlight door from the launch file is not decorative.

The third is the most interesting one, because it is a refusal. The line reads: Error: No observers, dropping inference. The intelligence service inside the notification stack ran inference on a notification, formed some conclusion about it, looked around for a consumer, found none, and threw the work away. On device, unobserved, unshipped. Whatever that inference was, it never left this Mac, and the log entry is the closest thing to a receipt you will get.

The notification neighbourhood

usernoted is the front door of a small district. Counting the launch jobs on a stock macOS install whose names contain notif, there are 19 of them, and each is a different thing:

Two extra copies of notifyd and one extra usernotificationsd were also running here, inside installed iOS simulator runtimes, which each bring their own little copy of the district. If you develop for iOS and count notification processes, that is why your number is higher than everyone else’s.

Is it a virus, and can you quit it

The virus question has a five second answer, and the checks are worth knowing rather than trusting: the real one lives at /usr/sbin/usernoted, is signed by Apple with platform identifier 26, runs as your user with launchd as its parent, and its manual page has shipped for years. A process with this name running from a Downloads folder or a browser profile, with any other parent, would be the moment to look closer. That is not what the real one looks like.

Quitting it is allowed and pointless, in that order. KeepAlive is true, so launchd restarts it within seconds of any exit, by design, because a Mac that silently stops showing notifications because a process died once is not acceptable. There is no daemon wide off switch in System Settings and there never has been. The switch that exists is better anyway, because it aims at the sender: System Settings, Notifications, one row per app, with Allow notifications at the top, then banner style, badges, lock screen, Notification Center, and an option to let notifications from your iPhone appear here too, which arrive by their own road: iPhone Mirroring carries them across with the help of replicatord, the widget sync daemon, before they become banners like any other. The settings file for that pane carries its own description, and it is a good one: Notification Center shows your notifications in the top-right corner of your screen. You can show and hide Notification Center by clicking the clock in the menu bar. Every option in that pane is a question about who may interrupt you and where, and usernoted is merely the staff that enforces the answers.

Where window managers fit

This page is about the machinery of interruption; a window manager is about what is already on the screen. They share one belief: you should be able to see everything that matters without anything hiding. Ribbon keeps windows full size on a single scrolling strip, so the window you want is one swipe away, nothing stacks, nothing shrinks, and notifications have a screen worth interrupting. It is $15, once, for up to 3 Macs, with a full refund within 10 days, and it runs on macOS 14 Sonoma and later on Apple silicon and Intel Macs. There is a browser demo of the strip if you want to feel it before installing anything.

The short version

usernoted is the notification daemon: it receives every local and remote notification, decides where it appears, badges your Dock, feeds Notification Center and Spotlight, and keeps the record in a database you are not allowed to read, as a privacy boundary rather than a technical failure. It runs as you, it has run uninterrupted since your last login, and it costs 36 seconds of processor time a day. Its manual page is one sentence from 2018, which is either modest or a mercy.

The two complaints that bring people here both have boring, healthy answers. A keychain prompt naming usernoted is about an app behind a notification, and Always Allow or re adding the account settles it. A CPU spike is a delivery storm, and the offending app’s row in System Settings is the fix. The daemon itself is not the story in either case, which after 27 days of quiet service seems fair.

How to look at your own

Everything above came from read only commands:

ps -Awwo pid,ppid,user,%cpu,rss,etime,command | grep "[/]usernoted"
man usernoted
plutil -p /System/Library/LaunchAgents/com.apple.usernoted.plist
launchctl print gui/$(id -u)/com.apple.usernoted
ls -l /usr/sbin/usernoted && lipo -archs /usr/sbin/usernoted
lsof -p $(pgrep -x usernoted) | grep -v -e Frameworks -e /usr/lib
log show --last 1h --predicate 'process == "usernoted"' | wc -l

The launchctl line is the honest one: runs 1, never exited, minimum runtime 10 seconds. The lsof line is the interesting one, because it names the database, the language tables, and every app whose localised name the daemon has read recently. Your list of apps will differ from Microsoft’s Office suite, and your line count will differ from 28,605, and in both cases the difference is your Mac’s own notification life, not a fault.

Questions

What is usernoted on Mac?

It is the daemon that delivers notifications to you: the banners that slide in from the top right corner, the badges on Dock icons, the list Notification Center keeps, and the alerts that appear on the lock screen. When any app posts a local notification, or Apple's push service delivers a remote one, usernoted receives it, decides where it goes, writes it into a database of past notifications, and shows it. Its manual entry, usernoted(8), dated July 2018, describes the whole job in one line: a daemon that provides notification services on the system. On the Mac measured here it has been running without interruption for 27 days, as the logged in user rather than root, and costs about 36 seconds of processor time a day.

Why does usernoted want to use the login keychain?

Because an app asked it to show a notification whose content sits behind your keychain. Mail and Calendar alerts, for instance, are tied to account credentials stored as keychain items. The code path that assembles the notification runs inside usernoted's process, under your user account, so when it touches a protected item, macOS attributes the access to usernoted and shows the prompt naming it. The keychain side of that access belongs to [the keychain daemon](/guides/secd-mac), the process every keychain question, from any app, is routed through. The prompt is really about the app behind the notification. If you trust the app, clicking Always Allow ends it. If the prompt returns in a loop, the item's access list has lost the app's entry, and the durable fix is removing and re adding the account in that app, which recreates the item with a correct access list. Note that the binary itself contains no keychain code: it links against the security machinery rather than implementing any.

Why is usernoted using so much CPU?

Normally it does not. Measured over 27 days of uptime on a 10 core MacBook Pro, the whole daemon had used 16 minutes 20 seconds of processor time, about 36 seconds a day, or four hundredths of one per cent of a single core. When it does spike, it is almost always a delivery storm: a chat app catching up on hundreds of muted messages, a calendar with a broken invite loop, an app re posting the same failed notification. usernoted is the messenger, so the fix is the sender: check which app is filling Notification Center, and in System Settings under Notifications, turn that app's Allow notifications switch off or set it to deliver quietly. If the spike passes in seconds, it was a burst, and bursts are the job.

Is usernoted a virus or malware?

No. It is Apple's own code. The copy measured here lives at /usr/sbin/usernoted on the sealed system volume, is signed with identifier com.apple.usernoted and platform identifier 26, is 6.2 MB, was built in September 2026, and runs as your own user account with launchd, process ID 1, as its parent. Its manual page has shipped with macOS since at least 2018. Malware can name itself anything, so the check that matters is the path and the parent: anything calling itself usernoted but running from your home folder, Downloads, or a browser profile directory, with a parent that is not launchd, would be worth a closer look. That arrangement was not present here and is not what the real daemon uses.

Can I quit or disable usernoted?

You can quit it and it will not stay quit. Its launch configuration has KeepAlive set to true, so launchd restarts it the moment it exits, usually within seconds, which is by design: a Mac that can miss notifications because someone killed a process is not acceptable, so the system treats the daemon as always on. There is no switch anywhere in System Settings that disables usernoted itself. The lever you actually have is per app and per place: System Settings, Notifications, where each app gets its own Allow notifications toggle, plus banner style, badges, lock screen and Notification Center checkboxes, and an option to allow notifications from your iPhone. Turning an app off there stops its notifications at the source, which is the fix people usually want when they go looking for this daemon.

Ready? Buy Ribbon for $15, or read all the guides.