macOS 27 Blocks Access to Other Apps' Data: What Breaks and How to Fix

Since macOS Sonoma, when one app tried to read another app's private data, you saw a prompt: "App" would like to access data from other apps. You could allow or deny it, and whatever broke, you knew why. macOS 27 Golden Gate removes the prompt. Access is now denied by default and without asking. The app that wanted the data just gets an empty result or an "Operation not permitted" error. You find out when a feature silently stops working.

Three related changes in the same release point the same way: XProtect can now block access to data malware commonly steals, apps can no longer read the privacy database directly, and launchd refuses to load property lists that carry the quarantine flag. This guide explains each one using Apple's own release-note wording, shows how to check what on your Mac is affected, and explains how to grant access deliberately when you need it — and when you shouldn't.

Key Takeaways

• No more prompt. In macOS 27, access to another developer's app data containers and app group containers is "denied by default" and managed in Privacy & Security settings. Apple's release notes list this under System Integrity Protection.
• Command-line tools are the awkward case. Apple lists a known issue: a process without a bundle ID can't be granted access to a specific app's data. The documented workaround is Full Disk Access "for the duration of the requirement".
• XProtect now guards "commonly targeted" data. Apple doesn't publish the list, so expect access to some app data to be refused even when a tool used to read it without trouble.
• Apps can no longer read the TCC privacy database directly. Scripts and tools that inspected TCC.db to report permissions need another approach.
• Quarantined LaunchAgents stop loading. On the Mac we checked, 9 of the 20 agents in ~/Library/LaunchAgents carried the quarantine attribute — all of them updater agents written by three third-party browsers.

What Changed: From a Prompt to a Default Denial

Apple has been tightening this area step by step:

Release	Access to another developer's app data
macOS 13 Ventura and earlier	Largely open to any process running as you
macOS 14 Sonoma	Protected; the user sees a prompt asking to allow access to "data from other apps"
macOS 15 Sequoia	Protection extended to app group containers
macOS 27 Golden Gate	Denied by default with no prompt; managed in Privacy & Security settings

The macOS 27 wording, from the System Integrity Protection section of the release notes:

Accessing files in other developer teams' app data containers and app group containers no longer prompts the user for authorization; such accesses are denied by default and can be managed by the user in Privacy & Security settings.

Two words in that sentence decide whether you're affected. Developer teams: the rule is about apps from different developers. A suite of apps from the same developer can still share a group container, because they're signed by the same team. Containers: the rule covers the sandboxed data folders apps keep in your Library. It doesn't cover your Documents folder, your Desktop or files you save yourself — those have their own Files and Folders permissions, which haven't changed in this way.

What Counts as "Another App's Data"

Sandboxed apps keep their private files in two places inside your home folder:

• ~/Library/Containers/ — one folder per sandboxed app, named by bundle ID, with the app's real data under Data/
• ~/Library/Group Containers/ — folders shared between several apps from the same developer, named either group.… or with the developer's team ID in front

Listing the folder names is harmless and shows the scale. On the Mac we used, still running Tahoe 26.5.2:

ls ~/Library/Containers | wc -l                    # 956
ls ~/Library/Group\ Containers | wc -l             # 187
ls ~/Library/Group\ Containers | grep -vc '^group\.'   # 70 named with a team ID

That's 956 app containers and 187 group containers, and each of them is now off-limits by default to every app from a different developer. Most of that is fine: a well-behaved app has no business reading another app's database. The trouble is the tools that read it legitimately for you.

What It Looks Like When It Breaks

The failure has no dialog, so it shows up as a symptom. The most common ones:

Symptom	Likely cause
ls: … : Operation not permitted in Terminal on a path under ~/Library/Containers/…/Data or ~/Library/Group Containers/	The shell's responsible app (Terminal, iTerm, your IDE) has no access to that app's data
A backup, sync or export tool skips an app's data or reports "permission denied"	The tool isn't allowed to read that container
An importer finds nothing to import from another app	Denied silently; the importer sees an empty or missing folder
A launcher, clipboard or automation tool loses a feature that read another app's data	Same denial, surfacing as missing results
A script run by cron or launchd fails on a path it read yesterday	Command-line process without a bundle ID — see the known issue below

"Operation not permitted" (EPERM) is the standard error you get when macOS privacy controls block a file access. It doesn't mean the file is missing, and it doesn't mean sudo will help — privacy protection applies to root as well.

Granting Access the Right Way

Apple places the control in System Settings → Privacy & Security, and the known issue below refers to the Files & Folders pane specifically. That's where access to another app's data is now granted per app, instead of through a one-time prompt.

For regular apps

1. Open System Settings → Privacy & Security → Files & Folders.
2. Find the app that needs the access and expand it.
3. Allow the specific data it needs, rather than broader access.

The exact layout of that pane on macOS 27 may differ from Tahoe's. Apple's notes describe where access is managed, not a click-by-click path. The principle is the same either way: grant the narrowest access that makes the feature work.

If an app's own documentation tells you to grant Full Disk Access instead, that works too — Full Disk Access covers app data containers. But it covers everything else in your home folder as well, including Mail, Messages and Safari data, so reserve it for tools whose whole job is reading your disk: backup software, disk analysers and the like.

For scripts, cron jobs and command-line tools

This is where Apple lists a known issue:

In the Files & Folders pane, a process without a bundle ID cannot be granted access to specific app data containers or app group containers owned by other developer teams.

Workaround: Consider if the access is necessary. If required, grant Full Disk Access to the process for the duration of the requirement.

A "process without a bundle ID" is any plain executable: a Python interpreter, a shell script run by launchd, a binary installed by Homebrew, a daemon started by cron. What matters is how it's launched:

• Run from Terminal, privacy decisions are attributed to Terminal (or iTerm, or your IDE), which does have a bundle ID. Granting access to that app usually covers commands you run in it.
• Run by launchd or cron, there is no app to attribute it to. The process itself needs the permission, and per the known issue, that means Full Disk Access for the binary.

To add a command-line binary to Full Disk Access, click + in the Full Disk Access list, press ⌘⇧G, paste the path (for example /opt/homebrew/bin/python3 or /usr/sbin/cron), and add it. Apple's phrasing — "for the duration of the requirement" — is worth taking literally. Grant it for the job, then remove it. An interpreter with Full Disk Access gives that access to every script it runs.

The XProtect Layer

A second note in the same section adds a layer of protection that doesn't depend on who's asking:

XProtect may now restrict access to app data that is commonly targeted by malicious software. Accessing files created by other developer teams' apps may be denied by default but may be managed by the user in Privacy & Security settings.

Apple doesn't say which data counts as "commonly targeted". What Mac infostealers look for is well documented by security researchers: browser profiles with saved passwords and cookies, cryptocurrency wallet data, and messaging-app session files. It's a reasonable guess, but still a guess, that XProtect's list overlaps heavily with those.

The practical effect for you: a tool that legitimately reads, say, another app's session or profile data may be refused on macOS 27 even after you've granted what looks like the right permission. If that happens, check Privacy & Security for a pending entry first. If there isn't one, it's worth asking the tool's developer whether they've tested on macOS 27 — the fix may have to come from their side.

Apps Can No Longer Read the Privacy Database

The TCC (Transparency, Consent and Control) database records which apps you've allowed to use the camera, microphone, screen recording, files and so on. The per-user copy lives at ~/Library/Application Support/com.apple.TCC/TCC.db. For years, tools with Full Disk Access could read it directly to report on permissions.

The macOS 27 release notes, under TCC deprecations:

Apps can no longer access the local TCC database directly.

Even on Tahoe, you need Full Disk Access to read it. From a shell without it, on our test Mac:

sqlite3 ~/Library/Application\ Support/com.apple.TCC/TCC.db "select service from access limit 1"
# Error: unable to open database ".../com.apple.TCC/TCC.db": authorization denied

On macOS 27, this direct route is closed for apps in general. Who notices:

• Mac admins whose compliance scripts or inventory extensions queried TCC.db to report permissions. The supported path is your device management tool's privacy preferences policy control (PPPC) reporting, not the database.
• Utilities that showed you "which apps have which permission" by reading the file.
• Malware, which read the database to find out what it could already reach. That's the reason for the change.

For your own Mac, System Settings → Privacy & Security remains the place to review and revoke permissions. Each category lists the apps that hold it.

The Other Silent Change: Quarantined LaunchAgents

This change isn't about app data, but it fails the same way — quietly — and it turned out to affect our test Mac more than anything else in this article. The release notes, under Launch Daemons and Agents:

launchd no longer supports loading launchd property list files with the quarantine extended attribute.

A LaunchAgent is a small .plist file in ~/Library/LaunchAgents that tells launchd to start a program at login or on a schedule: updaters, sync helpers, menu-bar tools. The quarantine attribute (com.apple.quarantine) is the flag macOS attaches to files that arrive from the internet — and to files created by apps that are themselves under quarantine rules.

Checking takes one loop:

for f in ~/Library/LaunchAgents/*.plist /Library/LaunchAgents/*.plist /Library/LaunchDaemons/*.plist; do
  xattr "$f" 2>/dev/null | grep -q com.apple.quarantine && echo "QUARANTINED  $f"
done

On our test Mac:

Folder	Property lists	Quarantined
~/Library/LaunchAgents	20	9
/Library/LaunchAgents	8	0
/Library/LaunchDaemons	27	0

All nine quarantined files were updater agents — three each — created by three third-party Chromium-based browsers. The third field of the quarantine value names the app that created the file:

xattr -p com.apple.quarantine ~/Library/LaunchAgents/some.agent.plist
# 0081;<timestamp>;<name of the app that wrote it>;<id>

At least one of them is loaded and running today on Tahoe. Going by Apple's note, on macOS 27 those agents won't load, so those browsers' background updaters would quietly stop. We haven't confirmed this on Golden Gate itself, and the vendors may already have changed how their agents are written. But it's exactly the kind of breakage that goes unnoticed for months: nothing fails visibly, and the browser just stops updating itself.

Fixing a quarantined agent

1. Update the app first. If the vendor has fixed it, the new version will rewrite the agent without the attribute.
2. If you must fix it by hand, inspect before trusting. Check what it runs:

plutil -p ~/Library/LaunchAgents/some.agent.plist          # look at Program / ProgramArguments
codesign -dv --verbose=2 "/path/to/the/program" 2>&1 | grep -E "Authority|TeamIdentifier"

3. Only if the program is what you expect, remove the attribute and reload the agent:

xattr -d com.apple.quarantine ~/Library/LaunchAgents/some.agent.plist
launchctl bootout gui/$(id -u) ~/Library/LaunchAgents/some.agent.plist 2>/dev/null
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/some.agent.plist

Don't strip quarantine from agents you don't recognise. Persistence through LaunchAgents is a classic malware technique, and this change is designed to stop a downloaded .plist from quietly installing itself. An unrecognised quarantined agent is a reason to investigate, not to reload it. Our login items and background apps guide explains how to trace an agent back to the app that installed it.

A Five-Minute Audit, Before or After Upgrading

Run these on Tahoe to see what's likely to change, or on macOS 27 to confirm what already has:

# 1. How much app data is now guarded by default
ls ~/Library/Containers | wc -l
ls ~/Library/Group\ Containers | wc -l

# 2. Scheduled jobs that may read other apps' data
crontab -l 2>/dev/null
ls ~/Library/LaunchAgents

# 3. Quarantined launch items that will stop loading
for f in ~/Library/LaunchAgents/*.plist /Library/LaunchAgents/*.plist /Library/LaunchDaemons/*.plist; do
  xattr "$f" 2>/dev/null | grep -q com.apple.quarantine && echo "QUARANTINED  $f"
done

# 4. Scripts that read the privacy database directly
grep -rl "TCC.db" ~/bin ~/scripts ~/.local/bin 2>/dev/null

Adjust the folders in step 4 to wherever you keep scripts. For each hit, ask the same question Apple's workaround asks: is this access actually necessary?

When Not to Grant Access

The change exists because "any process running as you can read any app's data" was the main thing Mac infostealers relied on. Before you hand out access to get a feature back, a few rules help:

• Prefer the narrow grant. Per-app access in Files & Folders over Full Disk Access; Full Disk Access for one binary over Full Disk Access for a whole terminal app.
• Make command-line grants temporary. Apple's own wording is "for the duration of the requirement". Put a reminder on the calendar to remove it.
• Be suspicious of new requests. An app that had no reason to read another app's data last month and asks for Full Disk Access this month deserves a second look.
• Never paste permission-granting commands from a web page you don't trust. Social-engineering campaigns that coax users into running Terminal commands are exactly how these protections get bypassed, as our article on Terminal paste malware warnings explains.

Troubleshooting Common Issues

"Operation not permitted" even with sudo

Problem: sudo ls ~/Library/Containers/…/Data still fails.

Solution: Privacy protection isn't a Unix permission problem, and root is subject to it too. Grant the access to the responsible app — Terminal, or whichever app launched the command — in Privacy & Security.

A launchd job fails but the same command works in Terminal

Problem: A scheduled script reads another app's data fine when you run it by hand, and fails on schedule.

Solution: In Terminal, the access is attributed to Terminal. Under launchd there's no app to attribute it to, and per Apple's known issue, a process without a bundle ID can't get per-app access. Grant Full Disk Access to the exact binary the job runs, and remove it when the job is no longer needed.

A backup tool silently skipped some app data

Problem: The backup completed, but an app's container is missing or empty in the backup.

Solution: Grant the backup app Full Disk Access — this is one of the legitimate cases for it — and run it again. Check the tool's log for permission errors; most report them even when the backup "succeeds".

An app lost a feature after the upgrade, with no error

Problem: An import, sync or search feature returns nothing.

Solution: Look in Privacy & Security for an entry you can allow, and check the vendor's release notes for macOS 27 compatibility. If the data it wants is the kind XProtect guards, the fix may need to come from the developer.

A background updater stopped updating

Problem: An app's auto-update has quietly stopped since the upgrade.

Solution: Check its LaunchAgent for the quarantine attribute with the loop above. Update the app manually first; that's the fix most likely to stick.

FAQ

Did macOS 27 remove the "access data from other apps" prompt?

Yes. Apple's release notes say such access "no longer prompts the user for authorization" and is "denied by default". You manage it in Privacy & Security settings instead of answering a prompt when it happens.

Does this affect apps from the same developer?

No. The rule applies to "other developer teams". Apps signed by the same developer team can still share data through their group containers, which is how suites of related apps keep working.

Is Full Disk Access still enough?

According to Apple's own workaround for the command-line known issue, yes — Full Disk Access grants access to app data containers. XProtect's new restrictions on commonly targeted data are the part Apple describes as separate, and these may still apply to some data.

Why can't my script read TCC.db anymore?

Apple's macOS 27 notes state that apps can no longer access the local TCC database directly. Use System Settings to review permissions, and your device management tool's reporting if you're an administrator.

Is it safe to remove the quarantine attribute from a LaunchAgent?

Only when you've confirmed what it runs, and that the program is signed by the developer you expect. Removing quarantine is exactly what malware wants you to do, which is why macOS 27 stopped loading quarantined agents in the first place.

Conclusion

The theme of these macOS 27 changes is consistent: data that belongs to one app is no longer available to another just because both run under your account, and a file downloaded from the internet no longer turns into a background process just because it landed in the right folder. For most people that's a clear gain, since it's the same access Mac infostealers depended on.

The cost is breakage you won't see announced. Scripts, backup tools, importers and even browser updaters can stop working quietly. Run the five-minute audit, grant access narrowly and temporarily where a tool really needs it, and when something goes quiet after the upgrade, check Privacy & Security before anything else.

Related reading: macOS 27 ignores "Open using Rosetta": fixing missing Intel plug-ins · Screen Recording and Full Disk Access keeps asking · "App is damaged" and the quarantine attribute · macOS 27 Golden Gate day-one update guide