# What Is tccd on Mac, and Why Is It Using High CPU?

> tccd is the macOS daemon that decides and remembers privacy permissions. Here is how to find the app that keeps it busy and reset one permission safely.

Published: 2026-11-15

tccd is the macOS daemon behind the permission prompts you see for the camera, microphone, screen recording, accessibility, Full Disk Access, files and folders, and automation. The name stands for Transparency, Consent and Control (TCC). It runs from `/System/Library/PrivateFrameworks/TCC.framework/Support/tccd`, one copy for the system and one for your account, and it is normally idle. When it shows up in Activity Monitor with high CPU, the usual story is an app asking for a permission over and over, so find that app instead of fighting tccd.

## What tccd does

When an app reaches for something protected, macOS asks tccd whether the app may have it. Apple's [Privacy & Security guide](https://support.apple.com/guide/mac-help/mchl211c911f/mac) lists the places where you review those answers, and each one has a service name that [Apple's tccutil documentation](https://developer.apple.com/documentation/Xcode/resetting-access-to-protected-resources-in-macOS) uses:

| Privacy & Security section | `tccutil` service |
| --- | --- |
| Camera | `Camera` |
| Microphone | `Microphone` |
| Screen & System Audio Recording | `ScreenCapture` |
| Accessibility | `Accessibility` |
| Full Disk Access | `SystemPolicyAllFiles` |
| Files & Folders | `SystemPolicyDesktopFolder`, `SystemPolicyDocumentsFolder`, `SystemPolicyDownloadsFolder` |
| Automation | `AppleEvents` |

Apple's documentation says the system prompts the first time an app asks for a protected resource and then remembers the person's choice. That remembered choice is what tccd stores and checks.

## See the processes

```bash
ps -axo user,pid,%cpu,rss,args | grep '[t]ccd'
```

On the Mac used for this page (macOS 27.2, 2026-11-14) there were two, both at 0.0% CPU and about 25 MB of memory: one run by `root` with the argument `system`, and one run by the logged-in account. macOS starts them from these launchd jobs:

```text
/System/Library/LaunchDaemons/com.apple.tccd.system.plist
/System/Library/LaunchAgents/com.apple.tccd.plist
```

In Activity Monitor, search for `tccd` and look at the column that shows the account name: `root` is the system copy, your own name is the per-account copy. Note which one is busy, because that tells you whether the requests come from a system-wide service or from something running as you.

## Where it keeps its decisions

There are two databases, both named `TCC.db`:

```text
/Library/Application Support/com.apple.TCC/TCC.db
~/Library/Application Support/com.apple.TCC/TCC.db
```

The system one is protected by System Integrity Protection, and reading it needs Full Disk Access. The other sits in your own Library folder. Treat both as internals you do not open. The Settings pane and `tccutil` are the supported ways to change a decision, and editing the files by hand can leave permissions in a state macOS did not expect. On a managed Mac, an MDM profile can also set some decisions: the launchd job for the per-account tccd on this Mac is configured to watch `/Library/Application Support/com.apple.TCC/MDMOverrides.plist`.

## Why it uses CPU or keeps prompting

| What you see | Likely reason | What to do |
| --- | --- | --- |
| The same prompt returns after you answer it | The app is not matching the stored decision, or the decision was reset | Check the toggle in Privacy & Security, then reset that one app (below) |
| A prompt returns after an app update or after opening a second copy of the app | macOS may see the copy as a different app, for example after a signature change | Remove the old copy, keep one, and grant it again |
| Sustained CPU in `tccd`, with no prompt | An app checks a permission in a loop | Find the app in the log (next section), quit it and update it |
| Prompts for settings you did not choose on a work Mac | A managed profile | Ask the person who manages the Mac |

Apple does not publish a list of reasons for a busy tccd, so these rows are the ones that fit its documented behavior (decisions are remembered per app) and what the log shows. The loop-of-checks row is an inference from the `preflight=yes` lines in the log below, which are checks without a prompt, and not a statement from Apple.

## Find which app is asking

The log names the app. This command only reads the log, and Control-C stops it:

```bash
log stream --predicate 'process == "tccd" AND eventMessage CONTAINS "AUTHREQ"'
```

Each request writes a few lines. The shape on this Mac was:

```text
AUTHREQ_CTX: msgID=..., function=<private>, service=kTCCServiceListenEvent, preflight=yes, query=1, ...
AUTHREQ_ATTRIBUTION: msgID=..., attribution={responsible={TCCDProcess: identifier=com.example.app, pid=..., responsible_path=/Applications/Example.app/...}, ...
AUTHREQ_RESULT: msgID=..., authValue=..., authReason=..., ...
```

`service=` names the permission, and `identifier=` and `responsible_path=` in the attribution line name the app. A single request is normal. The same identifier and service repeating many times a second is the app to deal with. To look back at what already happened instead of waiting, use `log show --last 10m` with the same predicate.

## Fix it safely

1. Open **System Settings › Privacy & Security**, open the section named in `service=`, find the app, and turn it off and on again.
2. Quit the app, open it again, and install its latest update.
3. If the stored decision is stuck, reset only that app and that service, as shown below.
4. Restart the Mac if tccd stays busy after the app is quiet.

The reset command takes the service name from the table and the app's bundle identifier, which the log prints as `identifier=`:

```bash
tccutil reset ScreenCapture com.example.app
```

Per `man tccutil`, `reset` clears the decision so the app prompts again the next time it needs the permission, and Apple's documentation says it affects only your account unless run with `sudo`. You will have to grant the permission again afterward. Replace `com.example.app` with the identifier from the log.

## What not to do

- Do not turn off System Integrity Protection to change a permission. It removes a protection the whole system relies on, and the Settings pane already covers every decision you are entitled to make.
- Do not edit `TCC.db` with `sqlite3` or any other tool, and do not delete it.
- Do not start with `tccutil reset All`. It clears every app's decisions for the account, so you would answer every prompt again. Reset one service for one app first.
- Do not end `tccd` in Activity Monitor as a fix. It is a system process that launchd serves on demand, so the next request brings it back.
- Do not grant Full Disk Access or Accessibility to an app just to stop its prompts. Grant access only to apps you trust with that data.

## Where Mole fits

[Mole](https://mole.fit/) asks for Full Disk Access, which it calls **Disk Access** in its first-run window and in **Settings**, with an **Open System Settings** button that goes to the right pane. To find out whether the permission is there, Mole opens the system `TCC.db` read-only and tries one `SELECT`; it never writes to it and never runs `tccutil`. Without the permission, Mole leaves Desktop, Documents, Downloads and iCloud Drive unopened and lists them as needing disk access, because opening them would raise one consent prompt per folder. In **Status**, a busy `tccd` appears in the process table with its CPU, search finds it when it is idle, and **Why is this running?** shows the launchd job that keeps it alive. Mole treats it as a system process and offers no way to end it. Mole does not tell you which app is making `tccd` busy, which is what the log command above is for. For other background processes, see [common Mac processes](https://mole.fit/blog/mac-processes-explained), and for a similar permission-related daemon, [syspolicyd](https://mole.fit/blog/syspolicyd-high-cpu-mac).

## FAQ

### What is tccd on Mac?

It is the Transparency, Consent and Control daemon, which decides and remembers whether an app may use the camera, microphone, screen recording, accessibility, files and other protected resources.

### Why is tccd using high CPU?

Usually an app is asking for a permission repeatedly. Find it with the `log stream` command above, then quit it, update it, or reset that one app with `tccutil reset`.

### Can I disable or delete tccd?

No supported way exists, and you should not try. It is a system component, and the permission toggles in System Settings depend on it.

### Is tccd a virus?

The real file is `/System/Library/PrivateFrameworks/TCC.framework/Support/tccd`, part of macOS. A process with that name running from your home folder or `/tmp` deserves a closer look.

### Is it safe to run tccutil reset?

Resetting one service for one app is safe: the app asks again and you answer again. Avoid `tccutil reset All` unless you really want every permission prompt back.

---

Canonical HTML page: https://mole.fit/blog/what-is-tccd-mac
Blog index for agents: https://mole.fit/blog/llms.txt
Site index for agents: https://mole.fit/llms.txt
