# tccd, the bouncer behind every permission prompt

> tccd is the daemon behind every Allow access to your camera question on a Mac. Measured: 117 permissions on its books and a database even ls cannot read.

Source: https://www.ribbonmac.com/guides/tccd-mac · Updated 2026-11-19

The first time an app wants your camera, macOS stops it and asks you a question in a small window with two buttons. Allow, Don't Allow. You answer in a second and never think about it again, but the Mac does: it writes the answer down, checks it every time that app touches the camera from then on, and asks again for the next app, and the next. Something runs that machinery. In Activity Monitor it is called tccd, and this page is the measured story of what it actually does.

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

## The receipts

`ps` finds the daemon twice, which is the first honest surprise:

```
root           485  RSS 11344K  up 28-06:11  CPU 26:07.12  0.0%
  /System/Library/PrivateFrameworks/TCC.framework/Support/tccd system
chethankumar  1051  RSS 13408K  up 28-06:11  CPU 70:01.47
  /System/Library/PrivateFrameworks/TCC.framework/Support/tccd
```

Two processes, one binary, both parented by launchd, both as old as the boot. The root copy runs with the argument `system` and holds the system wide decisions. The user copy runs as you and holds yours. Neither has used one percent of a core in four weeks; the ledger section below turns those two CPU numbers into a daily cost.

The binary is 3,382,464 bytes, triple architecture, signed `Identifier=com.apple.tccd`, `Platform identifier=26`, built 24 September at 12:40, the same build minute this series measured on contactsd and appstoreagent, which is what an operating system built as one piece looks like when you read the timestamps. It lives inside the TCC framework, in a Support folder, with the framework's own version numbers starting at 27.0.

And a third and fourth copy exist for developers: one per booted iPhone simulator runtime, under a long cryptex mount path in `/private/var/run`. The same three copies pattern this series has already met on the apsd, usernoted and logd pages. The two real ones are the ones in /System.

## One command in the manual

The daemon itself has no manual page at all. `man -k tccd` returns nothing appropriate: Apple publishes no specification for the process that guards every other process's access to your data.

What Apple does publish, dated Darwin, April 3, 2012, is a manual for one thin tool beside it, `tccutil(1)`, and its opening paragraphs are the closest thing to an official self description the privacy machinery has:

> The tccutil command manages the privacy database, which stores decisions the user has made about whether apps may access personal data.

Fourteen years old, and still exactly one command is supported: `reset`. The whole administration interface of macOS's permission system is a tool that can forget your answers and nothing else. If that seems thin for a subsystem this size, it is the point: the database is meant to be written by your clicks, not by scripts.

## The list

The daemon's own binary carries its vocabulary, and it is a long one. 117 strings inside tccd begin with `kTCCService`. Subtract the bare prefix and the `kTCCServiceAll` wildcard and you are left with the raw register of permissions macOS knows about, and reading it as a list is the fastest way to understand what the daemon is actually for.

There are the ones you have clicked through: `kTCCServiceCamera`, `kTCCServiceMicrophone`, `kTCCServicePhotos`, `kTCCServiceAddressBook`, `kTCCServiceCalendar`, `kTCCServiceReminders`, `kTCCServiceScreenCapture`.

There is a whole shelf of them for files and folders, all beginning `kTCCServiceSystemPolicy`: DownloadsFolder, DocumentsFolder, DesktopFolder, RemovableVolumes, NetworkVolumes, AppData, AppBundles, DeveloperFiles, SysAdminFiles, and AllFiles, which is the internal name of Full Disk Access. Every time an app has asked to touch your Downloads folder, it was this register item it was asking for.

There are the listening ones: `kTCCServiceListenEvent` for whether an app may watch keystrokes at all, `kTCCServicePostEvent` for sending them, `kTCCServiceAccessibility`, `kTCCServicePasteboard` for reading what you copy. The Accessibility row is the one window manager tools and launcher utilities keep knocking on, and the machinery behind it splits in two: tccd keeps the list, and the UniversalAccess family's own warner, universalAccessAuthWarn, prints pid is not allowed to access the accessibility API when an app tries the door without being on it. [The universalaccessd page](https://www.ribbonmac.com/guides/universalaccessd-mac) measured that family, clerk and warner both.

There are fossils. `kTCCServiceTwitter`, `kTCCServiceFacebook`, `kTCCServiceLinkedIn`, `kTCCServiceSinaWeibo`, `kTCCServiceTencentWeibo` are all still in the list, keys to integrations whose heyday was a decade ago, kept because a register that deletes rows breaks the sums.

There are codenames: `kTCCServiceLiverpool`, which [the cloudd page](https://www.ribbonmac.com/guides/cloudd-mac) found iCloud's daemon subscribing to, and `kTCCServiceWillow`, which guards Home app data. And there are the newest ones, which read like a list of next decade's questions: `kTCCServiceExternalAIProviderBlocked` and `kTCCServiceExternalAIVisibleToSystem`, permissions for external AI providers that were not in anyone's macOS vocabulary three versions ago. A watchOS family of thirty odd `kTCCServiceSensorKit` constants rounds it out, from wrist temperature to speech metrics. The Mac inherits the register whole.

## The words on the prompt

The best find is one file. The TCC framework ships its own localisation table, 95 English strings, and it holds the exact words of the prompts, written by Apple, sitting on disk:

```
Allow "%@" to access your camera?
Allow "%@" to access your microphone?
Allow "%@" to access your photo library?
Allow "%@" to access your calendar?
Allow "%@" to access your contacts?
"%@" would like to access files in your Downloads folder.
"%@" would like to access files on a removable volume.
"%@" wants access to control "%@".
```

The `%@` slots are where an app's name goes. The buttons are in there too: `Allow`, `Don't Allow`, and the graded ones, `Allow All Photos`, `Allow Full Access`. When a dialog asks you something on a Mac, the words were loaded from the daemon's own resources, translated into 44 locales, and the string keys show their age: the social era entries sit beside the AI era ones in the same file the prompts come from. On the other side of the calendar prompt sits a regular: [the calendar data daemon](https://www.ribbonmac.com/guides/calaccessd-mac) opens a connection to tccd every time a new calendar client checks in, a handshake its own log prints as tcc_send_request_authorization, and when it is denied location for travel time zone work the refusal lands in the calendar daemon's log instead.

## Two doors and a watcher

The daemon's two launch files describe its day precisely.

The user agent speaks on two channels: `com.apple.tccd`, its main door, and a second one named `com.apple.usernotifications.delegate.com.apple.tccd`, which is how the prompts themselves reach your screen through the notification system. Both copies are marked `EnablePressuredExit`, so the system reclaims an idle tccd's memory and relaunches it on the next knock, and both carry the same environment line the launch database shows for well behaved daemons: a log rate limit of 64 messages and a memory efficient allocator flag. The system copy declares a minimum runtime of 10 seconds, launchd's rule that a daemon which cannot live ten seconds is a daemon worth restarting.

Two wires are worth more than the plumbing. The launch files carry a watch path: `/Library/Application Support/com.apple.TCC/MDMOverrides.plist`. That is the file a device management system writes to force permissions on managed Macs, and tccd re-reads it the moment it changes, which is how a school or an employer can pre-answer the camera question for every machine they own. And both files subscribe to a launch event called, in full, `com.apple.tccd.tcc-settings-changed` in the privacy settings group: flip any toggle in the Privacy and Security pane and the daemon is notified that its own books were just edited, so the pane and the database never disagree for more than a moment.

## The vault

Where do the answers live? In a database called TCC.db under `/Library/Application Support/com.apple.TCC`, and here is the receipt from the measured Mac:

```
$ ls -l /Library/Application\ Support/com.apple.TCC/
Operation not permitted
```

Not permission denied because of a wrong flag; operation not permitted, to an administrator, on a folder listing. The database of permissions is itself protected by system integrity protection, sealed the way the system volume is sealed. That is the design: every secret on the machine is guarded by rows in one file, so the file is guarded absolutely. A per-user copy normally sits in the equivalent folder in your own Library; on the measured Mac it simply did not exist, every decision this account had ever made having landed in the system database.

The System Settings pane is the only window onto those books, and the pane's own configuration file proves the relationship: a property list inside the SecurityPrivacySettings extension that maps 108 pane rows to the daemon's constants, each entry carrying the key `tcc` beside a value like `kTCCServiceAddressBook`. Privacy and Security is not a list of unrelated switches. It is a viewer for tccd's database, rendered one row at a time.

## The quit rule

One string in the pane explains the single most common permissions complaint, the grant that appears to do nothing. The pane's localisation table carries a family of lines for it:

```
"%@" will not have full disk access until it is quit.
"%@" will not have access to your microphone until it is quit.
"%@" will have access to your contacts until it is quit.
"%@" will be able to access pasteboard contents from other
applications until it is quit.
```

Permissions are checked when an app asks, and most apps ask once at launch. Grant the permission while the app is running and the app never asks again, so it never learns. This is why the honest fix for a permission that seems stuck is not re-toggling it in the pane but quitting and reopening the app. The rule is not folklore; it is printed in the settings pane's own strings, one variant per service.

## The quiet ledger

In 28 days the user copy has spent 70 minutes and 1 second of processor time, about two and a half minutes a day. The root copy has spent 26 minutes, about a minute a day. Combined, the bouncer costs less than four minutes a day, which puts tccd above apsd's 38 seconds a day and below logd's nine minutes in this series' running ledger, comfortably inside the band of daemons you never need to think about.

Its log makes the same point more starkly: a two hour capture with the predicate set to this process returned zero lines. Not few lines. Zero. tccd is a daemon that only speaks when something changes, on a Mac where nothing had changed in two hours. Contrast that with [appstoreagent](https://www.ribbonmac.com/guides/appstoreagent-mac), which says the same sentence every ten minutes all day, or [logd](https://www.ribbonmac.com/guides/logd-mac), which cannot be quiet because everyone talks to it. Silence is what a healthy permissions daemon sounds like.

## When the column does move

The search interest has a shape: tccd mac cpu, tccd process mac high cpu, what is tccd in activity monitor. The honest answer has three parts.

A spike with a prompt on screen is the job. The daemon is asking, recording, and notifying every interested process that a decision just landed.

Sustained activity is volume, not fault: an app re-asking after an update, a management profile flipping overrides, a permissions repair tool resetting rows in bulk. The Privacy and Security pane shows which apps hold which grants, and recently changed rows are the place to look. A restart of the app doing the asking resolves almost every case, because the app re-reads its grants at launch, under the quit rule above.

And if tccd never appears at all in Activity Monitor without you searching for it, that is the normal case. It has no window, no menu bar item, and no reason to be seen.

## What Apple says, and does not

Apple's user facing page for this entire subject is called Control what you share on Mac, and its opening is the system's whole philosophy in two sentences: "Apps ask for permission the first time they want to use something on your Mac, explaining how they use the information. You can later change how much you want to share."

The page walks through the categories one by one, camera to microphone to files and folders, and across all 265 kilobytes of it the word tccd appears zero times. Apple documents the questions and the answers, never the asker. The daemon that holds the register of 117 permissions, speaks 44 locales of prompt text, watches the management overrides file, and guards the one database even an administrator cannot list, is left to pages like this one.

## The short version

tccd is the Mac's permissions daemon: two processes, one as root and one as you, sharing a 3.4 MB triple architecture binary inside the TCC framework. It owns the database of every allow and don't allow you have ever clicked, holds a register of 117 named permissions from camera to external AI providers, loads the prompt words from its own resource files, watches for management overrides, and reacts the moment you flip a toggle in Privacy and Security, which is a viewer onto its books. It costs about four minutes of processor time a day across both copies, logs nothing when nothing changes, and cannot be quit, disabled or usefully edited, only reset through tccutil, whose 2012 manual offers exactly one command. Its partner in enforcement is [sandboxd](https://www.ribbonmac.com/guides/sandboxd-mac), which polices the boundaries; tccd keeps the list of who was promised what.

## FAQ

### What is tccd on my Mac?

It is the privacy permissions daemon: the process behind every question that reads Allow something to access your camera, microphone, photos, calendar or files. macOS keeps a database of which apps you said yes to and which you said no to, and tccd is the daemon that owns it, asks the questions, records the answers and enforces them on every request that follows. Apple's own command line tool for it, tccutil, has one published sentence of definition: it manages the privacy database, which stores decisions the user has made about whether apps may access personal data. It runs as two processes, one as root for the system wide decisions and one as you for the per-user ones, and it is signed by Apple inside the sealed system volume. It is not malware and there is nothing to remove.

### Why are there two tccd processes in Activity Monitor?

Because permissions come in two flavours. The root copy, launched from com.apple.tccd.system.plist with the argument system, holds the system wide database: camera, microphone, screen recording, full disk access, the decisions that apply no matter who is logged in. Screen recording is the one that hands off: the permission lives here, but the actual capturing is done by other machinery: replayd, [measured in this series](/guides/replayd-mac), turns out to grab the frame even for the system's own screenshots, and the keystroke side of the shortcut flow belongs to SystemUIServer, [also measured in this series](/guides/systemuiserver-mac). The second copy runs as your user account from com.apple.tccd.plist and handles the per-user services: contacts, calendars, photos, reminders and the rest. Developers with iPhone simulator runtimes installed see one or two more, one per booted runtime, under a cryptex mount path; those belong to the simulators, and this same three copies and four copies pattern shows up in this series on apsd, usernoted and logd pages. The real ones live at /System/Library/PrivateFrameworks/TCC.framework/Support/tccd and have launchd as their parent.

### Why is tccd using CPU? Is high CPU normal?

On the measured Mac the user copy used 70 minutes of processor time over 28 days, about two and a half minutes a day, and the root copy about a minute more. Its log produced zero lines in two hours of watching, because it speaks only when permissions change: a prompt on screen, a toggle flipped in Privacy and Security, an app re-asking after an update. A short spike when a prompt appears is the daemon doing its job. Sustained CPU is not the daemon going wrong, it is volume: an app asking over and over, a configuration profile flipping permissions back and forth, or a freshly updated app re-requesting everything. Open Privacy and Security in System Settings, look at which app has a recently granted or denied row, and the levers are all there. The daemon itself has no throttle and needs none.

### Where are app permissions stored on a Mac?

In a database called TCC.db under /Library/Application Support/com.apple.TCC, and you cannot read it. On the measured Mac even ls on that directory returns Operation not permitted, to an administrator account, because the database of permissions is itself protected by system integrity protection; the decisions are worth guarding precisely because they are the keys to everything else. A per-user copy normally lives in the same folder inside your own Library, though on the measured Mac it did not exist at all, every decision having landed in the system database. There is also a file called MDMOverrides.plist in that folder that device management can use to force decisions, and tccd's launch configuration literally watches that path so it re-reads overrides the moment they change.

### How do I reset an app's permissions on a Mac?

Two ways. The graphical way is System Settings, Privacy and Security, where every category lists the apps that have asked; turn one off and on and the app asks again. The command line way is tccutil, whose manual dates to April 2012 and supports exactly one command: reset. tccutil reset AddressBook clears every app's address book decision, and tccutil reset All com.apple.Terminal clears every decision for one app. The honest warning from the manual is the word All: resetting everything means re-answering every question you have ever answered. And note the pane's own rule, printed in its strings: an app will not have full disk access until it is quit, so after changing a permission, restart the app before deciding the change did nothing.

### Is tccd the same as tccd0 or tccd1 in a temperature app?

No, and this confusion is worth settling because the search results mix them. In Windows monitoring tools, particularly on AMD processors, Tccd0 and Tccd1 are names for CPU temperature sensor diodes; people search them alongside Core Temp readings. That usage has no connection to the Mac process. The lowercase tccd on a Mac is the permissions daemon described on this page, the letters standing for the TCC framework it lives in. If you are on a Mac and seeing tccd in Activity Monitor, you are seeing the permissions daemon. If you are reading about tccd1 temperature on a PC forum, you are reading about a sensor, and neither one can catch the other's problems.
