HeartbeatHocusFocusFilesMacHyperTile
Guide

appstoreagent, the shopkeeper behind the App Store

appstoreagent is the daemon behind the App Store app: update checks, purchases, receipts. Measured: a ten-minute heartbeat and five seconds of CPU a day.

By Chethan Kumar S N · Updated

The App Store on a Mac has a ghost staff. You can close the app, never open it for weeks, and your installed apps still pick up updates, still launch without licence prompts, still know what you own. Something is doing that work with the store’s front door shut, and in Activity Monitor it is a 19.5 MB process called appstoreagent, running as you, with no window and no icon.

Everything below was measured the way this series measures: on a MacBook Pro running macOS 27.0.1 on Apple silicon, read only, nothing installed, no setting changed.

The receipts

ps finds the agent and its backend twin:

chethankumar  54728  RSS 7072K  up 1d2h37m  CPU 0:05.60  0.0%
  /System/Library/PrivateFrameworks/AppStoreDaemon.framework/Support/appstoreagent
_appstore     54779  RSS 1904K  up 1d2h36m
  /System/Library/PrivateFrameworks/AppStoreDaemon.framework/Support/appstored

Both have launchd as their parent. The agent runs as your user because it works for you: your update list, your purchases. The daemon runs as _appstore, a dedicated service account that exists so the store’s server-side work never needs your privileges or root’s, the same arrangement the softwareupdated page found with its own _softwareupdate user one floor down in the system.

The agent’s binary is 19,558,576 bytes, signed Identifier=com.apple.appstoreagent, Platform identifier=26, carrying three architectures, x86_64 and two arm64e slices. In a series that has measured a 37 KB notification daemon and a 6 MB update orchestrator, this is the largest single daemon binary so far. The App Store does a lot of things, and the size is the receipt.

One sentence of manual

Most daemons in this series get a paragraph. This one gets a line, dated 1 March 2018:

appstoreagent provides support for App Store.

Even the synopsis does it in four words: App Store support agent. That is the entire published specification of a process that validates purchases, and the page closes with the family’s standard instruction, that it is not intended to be invoked directly. Apple documents the shop, never the shopkeeper.

Fourteen doors

The launch file attaches fourteen message services to the agent, and reading them as a list is the fastest way to understand the job:

Three under its own name: appstoreagent.xpc, the main door, plus a .legacy door for old clients and a .CacheDelete door through which the agent volunteers its own caches for deletion when storage runs low, a genuine act of politeness registered with the system’s purge machinery.

One shared queue with its backend: appstored.xpc.storequeue.

One push door, aps.appstoreagent, its private line to the notification system. The apsd page found this agent among the 51 processes connected to the push daemon in a six hour window; store events arrive by push, not by polling.

Seven doors for ondemandd, the on-demand resources system: appinstall, appreview, CacheDelete, client, devtools, launchservices, and one literally called odrctl. On-demand resources are the iOS-brought feature where an app ships small and downloads its levels, assets or templates later. The Mac inherits the machinery wholesale, and this agent holds the doors.

And two more that name the money: storekitservice, the in-app purchase machinery, and the store’s notification delegate, which routes update badges to your screen.

The knock list

The same file lists exactly what wakes the agent, and it is a catalogue of the store’s anxieties:

An account change in the sandbox, and a trusted account change under a notification still named for a product that no longer exists: ASDItunesAccountDidChangeNotification. The iTunes name lives on inside the daemon like a bricked-up doorway with the sign still on it.

ASDRepairBundleID, the repair path, fired when a purchase needs fixing.

fairplayd.resync-fpkeybag, the DRM machinery re-synchronising its keys. FairPlay is what makes a store app refuse to run on a machine that cannot prove it bought it.

StorefrontChanged, fired when you switch the store’s country or region, because prices, currency and availability all change with it.

And the strangest: the agent subscribes to events about its own notifications. Did you dismiss the update badge, snooze it, let it expire, click it? Every outcome is delivered back to the agent, six event types in all, didDismissAlert, didSnoozeAlert, didActivateNotification and friends. The store does not just show you a badge. It keeps the receipt of what you did with it.

The ten-minute heartbeat

An hour of the agent’s log is 19 lines, and every one of them is the same sentence wearing a new timestamp:

Delivering connectionStatusChange from apsd: NO
Delivering connectionStatusChange from apsd: NO
Delivering connectionStatusChange from apsd: YES

Six times an hour, once every ten minutes, the agent checks that its push connection to Apple is alive, is told no, no, yes, and goes back to sleep. That heartbeat is nearly the whole cost of the agent: 5.6 seconds of processor time over a day and a half, about five seconds a day. In this series’ ledger that ties assistantd, the Siri daemon, for the cheapest measured, and sits under routined’s sixteen seconds, suggestd’s twenty one, contactsd’s thirty one and apsd’s thirty eight. The shopkeeper spends his day checking the till.

Memory sits at about 7 MB, with eighteen live connections held, and the running job’s state reads: runs 23, last exit JETSAM_REASON_MEMORY_IDLE_EXIT, immediate reason xpc event. Started when knocked, reclaimed when idle, twenty three hires so far.

The receipt inside the app

How does a Mac know an app was bought? Not by a serial number in a safe. The proof travels inside the app itself, in a folder called _MASReceipt, and this Mac has exactly one store-delivered app to show for it:

$ ls -l /Applications/Xcode-27.0-backup.app/Contents/_MASReceipt/
-rw-r--r--  1 root: wheel  4832 Oct 20 17:07 receipt

A 4,832 byte file, signed along with the app so it cannot be faked, which is why a store app launches without the downloaded from the internet warning. The uninstall guide uses this same receipt to show how to tell store apps from direct downloads. When an app launches or revalidates, it is this agent’s side of the machinery that checks the receipt against the account, with FairPlay holding the keys.

The purchase has a physical shape, the download has a dispatcher, and the installation has a tradesman: installd, summoned in shifts when something actually needs placing. The agent never installs anything. It sells, verifies, and hands over the parcels.

When the column does move

Search interest in this process clusters on one release, and the queries are specific: appstoreagent cpu, appstoreagent network, appstoreagent macos 27. The honest answer is that a healthy agent is nearly invisible, so a moving column is the store doing business.

An update download is the common case, and it shows as network first and CPU second, because the agent fetches what your App Store settings allow. The automatic updates section of the App Store pane in System Settings is the switch that decides whether there is anything to fetch.

An account event is the second: sign in, sign out, a licence re-check after an app update, a FairPlay resync. These are short.

The scheduled sweep is the third, and it explains the dasd pairing people keep searching for. The agent has one maintenance task, a non-repeating job that dasd, the system’s background scheduler, is asked to run between 120 and 180 seconds after the Mac settles, once, and only after setup has completed, and with no requirement for external power. A blur of appstoreagent and dasd activity a few minutes after login is that sweep on schedule, not a fault.

The family photo

appstored, the backend, runs as _appstore with 1.9 MB of memory and no measurable CPU, and talks to Apple’s servers so the agent does not have to. appstorecomponentsd handles the store’s page furniture. On demand, a further family assembles: the asset and download daemons that move an actual update, summoned by the store queue and released after. And on this Mac, two simulator runtimes each run their own small appstored, which is why developers sometimes count three store processes in Activity Monitor and wonder which one is real. The one running as _appstore from /System is real. The cryptex ones belong to the simulators.

What Apple says, and does not

The App Store User Guide runs to well over a hundred kilobytes per page across its welcome and its topics, covering purchases, reinstalls, redownloads and the jiggle-to-delete gesture. The word appstoreagent appears zero times in the pages measured here. Apple will tell you to open the App Store, click your name, find the app in your purchases and click the download button. It will not tell you which process stands behind that button, checks the receipt, watches the badge, and listens on fourteen doors while the store itself is closed. That is what this page is for.

The short version

appstoreagent is the App Store’s back office: a 19.5 MB agent running as you, with fourteen message services, woken by account changes, FairPlay resyncs, storefront switches and its own notification badges, keeping a ten-minute heartbeat on its push connection, validating the 4,832 byte receipts that ride inside every store app, and costing about five seconds of processor time a day, tied with the Siri daemon for the cheapest in this series’ ledger. CPU or network spikes are store business, usually an update download governed by the automatic updates switches in the App Store pane. Its backend is appstored under the _appstore user, its installer is installd, its scheduler is dasd, and Apple’s own guide documents the storefront it serves without once naming it.

Questions

What is appstoreagent on Mac?

It is the background agent that supports the App Store. Its manual page, appstoreagent(8), dated March 2018, sums up the whole job in one sentence: appstoreagent provides support for App Store. In practice that means checking whether your installed apps have updates, downloading them when your settings allow it, validating the receipts that prove which apps you own, handling in-app purchases through a service literally called storekitservice, and watching for account and storefront changes even when the App Store app itself is closed. It runs as your user, not root, from the AppStoreDaemon framework, and on the measured Mac it is the largest single daemon binary in this series at 19.5 MB, with fourteen message services attached to it.

Why is appstoreagent using CPU or network?

Its idle cost is almost nothing: 5.6 seconds of processor time over a day and a half on the measured Mac, about five seconds a day, with a log that shows one push connection check every ten minutes and nothing else. When it does move, the work is real store work: an update check after the App Store or Settings is opened, an automatic download if your App Store settings allow one, a receipt or FairPlay licence check when an app launches or an account re-signs in, or on-demand resources being fetched for an app that uses them. A sustained spike with the store closed usually means an update is downloading in the background. The levers are in System Settings, in the App Store pane: the automatic updates section decides whether this agent has anything to fetch, and turning it off is the only version of quieting it that means anything.

What is appstoreagent dasd?

Two processes that people keep seeing together. dasd is the background task scheduler, the part of macOS that decides when maintenance work is allowed to run, and appstoreagent has exactly one maintenance task on its books: a job named scheduleTasks with a priority of Maintenance, which dasd times. The launch file asks for it to run between 120 and 180 seconds after the Mac is settled, once, and only after the setup assistant has completed. So if you have searched the two names together, you likely caught the agent doing its scheduled post-startup sweep, with dasd holding the stopwatch. Neither process is misbehaving; one is the errand, the other is the clock.

Why is appstoreagent running when I closed the App Store?

Because the App Store app is a client, not the machinery. The agent's launch file has no RunAtLoad key, so it does not even start with the Mac; it starts when something knocks, and the running job's state on the measured Mac said exactly that: immediate reason, xpc event. Closing the store closes the front door, not the shop. The agent also holds the store's notification delegate, so update badges and their snoozes and dismissals are routed through it, and it listens to the push daemon for store events around the clock. It has been started and stopped by the system 23 times in the current stretch of uptime, reclaimed for its memory whenever it is idle, and it always comes back on the next knock.

What is the difference between appstoreagent and appstored?

They are the two halves of the store, from the same AppStoreDaemon framework. appstoreagent runs as you, in the graphical session, and is the client-facing half: your updates, your purchases, your receipts. appstored runs as a dedicated service user called _appstore, the same pattern the software update machinery uses with its _softwareupdate user, and is the backend that talks to Apple's servers. Around them sit appstorecomponentsd and a family of on-demand services for app installation, app review and on-demand resources, the iOS feature that lets an app download its features lazily. Developers with simulator runtimes installed also see simulator copies of appstored in Activity Monitor, one per booted runtime, which is normal and separate from the real one.

Can I quit or disable appstoreagent?

Quitting accomplishes nothing. The system already recycles it on purpose: the launch job carries EnablePressuredExit, the last exit on the measured Mac reads JETSAM_REASON_MEMORY_IDLE_EXIT, and force quitting just produces restart number twenty four, which launchd performs without being asked. There is no switch that says appstoreagent off, and there should not be, because automatic app updates, receipt validation and in-app purchases all live behind it. What you can control is its workload: the automatic updates section in the App Store pane of System Settings, and signing out of your Apple Account in the store, which leaves the agent with nothing to mind.

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