HeartbeatHocusFocusFilesMacHyperTile
Guide

fileproviderd, the process that puts cloud storage in your Finder

fileproviderd is the daemon behind the cloud folders in your Finder, iCloud Drive included. What it does, where its database is, and when it goes busy.

By Chethan Kumar S N · Updated

Two kinds of search land here, and they arrive from opposite directions.

One is a person who opened Activity Monitor and found a process called fileproviderd near the top of the CPU list. It has an unfamiliar name, it is not an app they remember installing, and it has no icon, no window and no obvious way to find out what it wants. The other kind of search is much blunter and much angrier: the cloud folder in the Finder is stuck, or a file will not open, or a laptop is warm on a desk with nothing running, and somewhere in the middle of that complaint there is a sync that never quite finishes.

Both come down to the same daemon, and the answer is less sinister than either search expects. fileproviderd is how macOS shows cloud storage as folders. It is the machinery behind every entry you have ever seen in the sidebar that lives on somebody’s servers, iCloud Drive included, and the extensions for those services are small programs it hosts and drives.

Everything below comes from reading the process, its man page, the property list that launches it, its entitlements, its own state dump, its log and the files it holds open, on an M1 Pro MacBook Pro running macOS 27.0.1, build 26A434, with 25 days of uptime and no third party cloud app installed. Nothing was quit, nothing was installed, no sync setting was changed, and the one folder that macOS protects was measured rather than opened.

What the process is, in one command

$ ps -Awwo pid,ppid,user,%cpu,rss,time,etime,args | grep "[f]ileproviderd"
 1102     1 chethankumar       0.0  12944   8:38.40 25-18:08:10 /System/Library/PrivateFrameworks/FileProvider.framework/Support/fileproviderd

One line, and every column in it is worth reading.

Parent process 1 is launchd, so nothing you launched started this. The user is you rather than root, which is the first clue that this is a per session daemon rather than a system one. The number in the time column is processor time, not elapsed time: 8 minutes 38 seconds, against 25 days 18 hours of having existed. That works out at about 0.023 per cent of one core over the entire life of the process, and it is the single most useful number on this page, because a process that has run for 25 days and spent eight and a half minutes thinking is not the reason a Mac feels slow.

Resident memory moved between 8.6 MB and 13 MB across samples taken an hour apart, which is normal for a process that maps the folder listings it is asked for and releases them again.

The path in the last column is a symlink, which is worth knowing before you go looking for it:

$ ls -l /System/Library/PrivateFrameworks/ | grep -i fileprovider
lrwxr-xr-x   1 root  wheel    36 Sep 24 12:40 FileProvider.framework -> ../Frameworks/FileProvider.framework
drwxr-xr-x   7 root  wheel   224 Sep 24 12:40 FileProviderDaemon.framework

The framework named in the process list is a link into /System/Library/Frameworks, and the real code sits in FileProviderDaemon.framework alongside it. That second folder is the interesting one. It contains two XPC services called AppStoreService.xpc and FPCKService.xpc, and a diagnostic bundle called FileProviderDiagnosticExtension.appex, which is what runs when you generate a system diagnostics report and it collects sync state. Its own version file says the build is 4838.0.125 and the project is named FileProvider_executables, and the dump quotes the same string back as FP Version: 4838.0.125, so the daemon numbers itself consistently.

The binary is a universal Mach-O with three slices, which is unusual enough to be worth a line:

$ lipo -archs /System/Library/Frameworks/FileProvider.framework/Support/fileproviderd
x86_64 arm64e arm64e.x1

Two of those are for Apple silicon and one is for Intel. On an M1 Pro, arm64e.x1 is the slice that runs, and it is the variant compiled for Apple’s own hardware rather than for third party distribution. The file is 262,304 bytes, signed on 9 August 2026 under the identifier com.apple.fileproviderd with TeamIdentifier=not set, which is what an Apple platform binary looks like: no team, no sealed resources, because the whole system is sealed instead.

The job that launches it, and why its name is not the process name

There is no com.apple.fileproviderd in either launch folder, and that is the first thing that trips people up when they go hunting for it in the way this site’s other pages have taught them. One property list starts this daemon, and it is called something else:

$ ls -l /System/Library/LaunchAgents/com.apple.FileProvider.plist
-rw-r--r--  1 root  wheel  1905 Sep 24 12:40 /System/Library/LaunchAgents/com.apple.FileProvider.plist

1,905 bytes, one label, and a Program key that points at the binary above. The label is com.apple.FileProvider, without the trailing d. That is why a search for fileproviderd in the launch folders comes back empty, and why the launch job’s name and the process name only match if you know to drop the last letter.

The plist is where three of the interesting facts about this daemon live.

$ plutil -p /System/Library/LaunchAgents/com.apple.FileProvider.plist
{
  "EnablePressuredExit" => true
  "EnableTransactions" => true
  "EnvironmentVariables" => {
    "LIBDISPATCH_STRICT" => "YES"
    "OBJC_DEBUG_MISSING_POOLS" => "halt"
  }
  "Label" => "com.apple.FileProvider"
  ...
  "LimitLoadToSessionType" => "Aqua"
  "POSIXSpawnType" => "Adaptive"
  "ProcessType" => "Adaptive"
  "Program" => "/System/Library/PrivateFrameworks/FileProvider.framework/Support/fileproviderd"
}

EnablePressuredExit set to true is the daemon’s consent to being killed when memory gets tight, and ProcessType set to Adaptive is the corresponding promise about its own priorities: the system is allowed to slow it down and reclaim it, because nothing about showing cloud folders is urgent. LimitLoadToSessionType set to Aqua is the other half of that, and it confirms what the process list showed. This daemon is loaded for a logged in graphical session, so it belongs to you, and there is no system wide copy of it running as root.

The environment block is Apple talking to its own engineers. OBJC_DEBUG_MISSING_POOLS set to halt means a missed Autorelease Pool is a crash rather than a warning, and LIBDISPATCH_STRICT turns dispatch misuse into a fault. Nobody ships those in production for a normal app. In a daemon that coordinates file operations for every cloud service on the machine, they are a way of failing loudly in internal testing instead of silently in the field.

Then there is the part that describes what actually wakes it up. Three things do, and none of them is a clock:

  "LaunchEvents" => {
    "com.apple.bg.system.task" => {
      "com.apple.FileProvider.fpfs.telemetry" => {
        "Interval" => 86400
        "Priority" => "Maintenance"
        "RepeatingTask" => { "Interval" => 86400 }
        "RequiresExternalPower" => false
        "RequiresUserInactivity" => false
      }
    }
    "com.apple.fsevents.matching" => {
      "com.apple.bird.fsevents" => { "Path" => "~/Library/CloudStorage" }
    }
  }

The telemetry task is one of the two scheduled jobs this daemon has, and it runs at maintenance priority, which in this vocabulary means the scheduler is free to defer it until the machine is not busy. The filesystem event subscription is the more telling one. It is registered on ~/Library/CloudStorage, which is the folder where third party cloud providers put their placeholder folders, and it exists so that when something appears there the daemon hears about it.

Seven Mach service names are also declared, and they read like a list of doors:

Door declared in the plistWhat knocks on it
com.apple.FileProviderthe main entry point, used by anything wanting the sync engine
com.apple.FileProvider.cache-deletethe storage pressure system, asking what can be evicted
com.apple.FileProvider.sim2hostApple’s own tooling, for driving a simulator’s files from the host
com.apple.fileprovider.extension.pushpush notification delivery into an extension
com.apple.fileprovider.extension.push.developmentthe same, for development builds
com.apple.fileprovider.pushkitthe push channel a cloud service uses to announce a remote change
com.apple.corespotlight.daemon.fileproviderSpotlight, reading through the daemon to index cloud items

launchctl then reports the behaviour in numbers, and this is the block that settles what kind of process this is:

$ launchctl print gui/$(id -u)/com.apple.FileProvider
  state = running
  minimum runtime = 10
  exit timeout = 5
  runs = 1
  pid = 1102
  immediate reason = ipc (mach)
  forks = 0
  execs = 1
  last exit code = (never exited)

One run since the machine booted. The reason it is awake is ipc, which means another process sent it a message, and the process has never exited at all. There is no KeepAlive in the plist, so nothing is holding it open, and there is no timer listed as a wake source. In 25 days it has been started exactly once and has stayed up because something has always wanted it, which on a Mac with iCloud on is most of the time.

Under that block there is one more scheduled job, and it is the one that explains the slow laptop people sometimes blame on sync:

  event triggers = {
    com.apple.FileProvider.maintenance.fpck-repair => {
      monitor = com.apple.dasd
      "InvolvedProcesses" => [ "fileproviderd", "FPCKService" ]
      "RequiresExternalPower" => true
      "RepeatingTask" => {
        "MinDurationBetweenInstances" => 69120
        "Interval" => 86400
      }

fpck-repair is the consistency check, and the letters stand for File Provider Consistency Kit. It runs at most once a day, with a floor of 69,120 seconds between instances, which is 19.2 hours, and it requires external power before it will start. It also names the two processes involved, which is how FPCKService.xpc in the framework folder earns its keep. If you have ever had a MacBook on a charger at night do something that sounds like a disk repair, this is a candidate.

Two providers, and the two bundles that are not syncing anything

The daemon has its own command line tool, and the quickest honest look at the subsystem is one command with it:

$ fileproviderctl dump
Date/Time:         2026-11-15 00:18:16 +0000
OS Version:        26A434
FP Version:        4838.0.125
uid:               501

2 providers

Two providers, on a Mac with no Dropbox, no Google Drive, no OneDrive and no Box. On a machine with several cloud apps installed, that first number is the one that matters, because each of them registers a provider of its own and they all live inside this single daemon. What follows is a block per provider, and side by side they tell you why “fileproviderd is part of iCloud” is only half right:

iCloud DrivePhotos
Provider namecom.apple.CloudDocs.iCloudDriveFileProvidercom.apple.Photos.PhotosFileProvider
Supports enumerationyesno
Supports FPFSyesno
Bundle/System/Library/PrivateFrameworks/CloudDocs.framework/PlugIns/com.apple.CloudDocs.iCloudDriveFileProvider.appexinside Photos.app, in its PlugIns folder
Containing appthe provider itselfcom.apple.Photos
Coordination purposecom.apple.birdcom.apple.Photos.PhotosFileProvider
Storage<GroupContainers>/group.com.apple.iCloudDrive/...<GroupContainers>/group.com.apple.Photos.PhotosFileProvider/...

Apple’s own Photos app registers a file provider, which is why Photos appears in save dialogs alongside cloud folders, and it answers no to enumeration and no to FPFS, which means it does not present a browsable folder and does not use the newer on demand file system backend. The iCloud Drive provider answers yes to both, and its coordination purpose is com.apple.bird, which is the name of the daemon covered on the bird page. That is the join between the two pages in one line: bird is the extension, fileproviderd is the host.

A fourth name shows up if you ask the system which bundles are registered as file providers, and it explains why the count of two is worth checking rather than assuming:

$ pluginkit -mAv | grep -ci fileprovider
4

Four bundles, of which two are providers that own domain content, one is the managed variant of the iCloud Drive provider that a company’s device management can switch on, and one is the diagnostic extension mentioned above. The full list, with the paths Apple installed them from:

com.apple.Photos.PhotosFileProvider            /System/Applications/Photos.app/Contents/PlugIns/PhotosFileProvider.appex
com.apple.CloudDocs.iCloudDriveFileProvider    /System/Library/PrivateFrameworks/CloudDocs.framework/PlugIns/...appex
com.apple.FileProviderDaemon.diagnostic        /System/Library/PrivateFrameworks/FileProviderDaemon.framework/PlugIns/FileProviderDiagnosticExtension.appex
com.apple.CloudDocs.iCloudDriveFileProviderManaged  /System/Library/PrivateFrameworks/CloudDocs.framework/PlugIns/...appex

Every one of them is in a System folder. That is not a coincidence, it is the design: a cloud service does not get to write into the Finder’s file system, it ships an extension, and the system hosts it. It is also why the answer to “which app is making fileproviderd busy” is never visible in the process list. The process is the host. The work belongs to an extension, and the dump names the extension, the domain and the pid that requested the job.

Where it keeps its books

The daemon holds about forty files open at rest, and the interesting ones form a small, tidy set. They cannot be listed, so they were found the other way round:

$ lsof -p 1102 | grep FileProvider
Support/FileProvider/2E70FB84-FB82-4956-9A27-8C8ADF5396D0/database/db
Support/FileProvider/2E70FB84-FB82-4956-9A27-8C8ADF5396D0/database/db-wal
Support/FileProvider/2E70FB84-FB82-4956-9A27-8C8ADF5396D0/database/db-shm
Support/FileProvider/2E70FB84-FB82-4956-9A27-8C8ADF5396D0/wharf/wharf
Support/FileProvider/2E70FB84-FB82-4956-9A27-8C8ADF5396D0/wharf/wharf/oldVersions

That is one folder per domain, under ~/Library/Application Support/FileProvider. The UUID in the path is that domain’s storage folder, and lsof is the only ordinary way to learn the names, because of this:

$ ls ~/Library/Application\ Support/FileProvider
ls: /Users/chethankumar/Library/Application Support/FileProvider: Operation not permitted
$ stat -f "%Sp %N" ~/Library/Application\ Support/FileProvider
drwxr-xr-x /Users/chethankumar/Library/Application Support/FileProvider

Read those two lines together, because the contradiction is the whole point. The permissions say 755, which normally means anyone can list it. There is no ACL and no flag on the folder either, and the same command on the other 77 folders in Application Support works fine. macOS is blocking the listing at the kernel level rather than through permissions, which is the protection it puts around sync state, and the same thing happens to ~/Library/Application Support/CloudDocs. It is not a fault and it is not something to work around. It does mean the file names below come from the list of open files rather than from a directory listing, and that nothing here says what is inside the database rows.

Sizes, since a size is what you can actually have:

FileSizeLast modified
database/db6,909,952 bytes2026-09-19 21:41
database/db-wal3,073,552 bytes2026-09-19 21:41
database/db-shm32,768 bytes2026-09-19 21:41
wharf/wharf256 bytes2026-09-19 21:41
wharf/wharf/oldVersions64 bytes2026-09-19 21:41

A 6.9 MB SQLite database and its 3 MB write ahead log, which is the same shape as the other daemons in this series. The wharf entry is the odd name and the interesting one: a wharf is where goods are unloaded, and in Apple’s sync engines it is the staging area for items the engine has just taken delivery of, with an oldVersions folder inside it for the copies it is about to replace. It is 256 bytes here, which is the size of an empty structure, because nothing has been delivered to this Mac’s iCloud Drive through a third party provider at all.

The timestamps deserve a raised eyebrow, and then an explanation rather than a theory. All five files report 2026-09-19 21:41, which is when this Mac was set up. A database that is open for writing and has not changed its modification time in eight weeks is not a mystery once you put it next to the rest of this page: the daemon is idle, the domain was created once, and SQLite in write ahead logging mode appends to the log rather than rewriting the main file. The counters shown later in the dump agree, and they are the ones to trust.

One more thing lives outside that folder, and the dump prints it in a section of its own:

== FileProvider xattrs ==
2E70FB84-FB82-4956-9A27-8C8ADF5396D0
    com.apple.file-provider-domain-id: com.apple.CloudDocs.iCloudDriveFileProvider/511E0CFB-7EC9-400B-BC22-4B0661B86ED9

That is the answer to a small puzzle. The folder is named with one UUID, 2E70FB84, and the domain inside it is identified by a different one, 511E0CFB. The extended attribute on the folder is what ties them together, so if you ever need to know which domain a storage folder belongs to, that attribute is where the mapping is written down. There is also a shared cache of these mappings in a group container, at group.com.apple.FileProvider.DomainCaching, and in this case it holds exactly one line, the same iCloud Drive domain.

What it was doing when it was asked

fileproviderctl has four commands, and the useful one is the last, described in its own man page as follows: dump dumps the state of the file provider subsystem, the sync engine and all providers. On this Mac that produced 17,896 lines and 4 MB of text, most of it the work list, and the first few hundred lines are the ones worth quoting.

The domain section begins with who is watching:

domain: 5{34}9 (i{9}e)
 observing:{process [86731], process [58174], ... process [71173]}; grace period timer not running
 alive (1673) via ExtensionKit for:
     enumerator of s:icloud/5{34}9/__fp/fs/fileID(340444), al:n for pid=1651 name=Finder ... isPOSIX=0
     enumerator of s:icloud/5{34}9/root, al:y for pid=1651 name=Finder ... isPOSIX=0
     enumerator of s:icloud/5{34}9/trash, al:n for pid=1651 name=Finder ... isPOSIX=0
     enumerator of s:icloud/5{34}9/root, al:y for pid=1659 name=Siri AI ... isPOSIX=0

Thirty one processes were registered as observers of this one cloud domain at the moment of the dump, and they are not cloud apps, they are ordinary things that have looked at a folder: the Finder, the scheduler, and 29 others with pids and no names in this excerpt. An enumerator is what it sounds like, a handle for walking a folder, and four were live. Three belong to the Finder, which was watching the domain root, the trash and one specific item, and the fourth belongs to Siri AI, which had asked for the root. Note the isPOSIX=0 on all four, which distinguishes a request coming through the file provider API from one arriving as a plain POSIX read.

The paths in that output are not what they look like, and it is worth pointing out before quoting more of them. 5{34}9 (i{9}e) is the daemon redacting a string rather than showing it, and the number in braces is the count of characters it hid. The convention becomes obvious in the root line further down:

  + root: ~/L{5}y/M{14}s

Five characters hidden after the L, and 14 after the M. That is ~/Library/Mobile Documents, which is where iCloud Drive’s files actually live. So the tool is printing the shape of a path and hiding the middle, which is why the marker itself is a fact and not an omission: a dump that says {14} tells you the length of a folder name without telling you the name.

Then the numbers, in the order the dump gives them:

What the dump calls itValue on this Mac
pending-indexable-count5,959 (updates 5,896, undownloaded 0, overlap 0, deletions 63)
total-indexable-count5,959 (items 5,896, deletions 63)
reconciliation entries5,896
snapshot fp entries5,896
error generation137
database versionv13.4.r202507081658
active enumerators4
operations in the action engine0
apps being monitored0

Two of those deserve a paragraph each, and one of them deserves an apology.

The 5,959 is the queue for Spotlight. The dump lists it under the indexer with two sibling lines that read enabled: no and indexing: no, which together say the queue exists, is counted, and is not being worked right now. It has two parts: 5,896 items that have changed since something last looked, and 63 deletions. The reconciliation list underneath is the same 5,896 number again, and that list is the clearest thing in the whole dump, because it pairs the two sides of a sync:

 <fs:✅  fileID(343280) content:watch sver:root/c{13}s cver:343280> <-> <fp:✅  a2c content:watch sver: cver:> dir sched:utility#1789834341.9199471

Read left to right: an item on the file system side, matched to an item on the file provider side, both ticked, with the folder marked as watched and a scheduling stamp for when it will be looked at again. sver and cver are the server version and the client version of the item, and on the file system side they point at a real inode number while on the provider side they are still empty. That is not an error. It is a local file that has not been sent anywhere yet, which on this machine is every file, because this Mac’s cloud folder has been filled from the local side.

The apology is for alive (1673). It appears immediately before the enumerator list and it looks like a count of something alive. It is not, or not in any way the command line explains: the same style of number shows up as usage:2026-11-13 05:04:40 +0000 in the scheduler section and as dirty:false last:1794546081 in the pacer, which are timestamps in a compressed form. 1673 is a tick count, not a population. The population next to it is the 31 observers, which the line before it states in full. Anyone reading that line as 1,673 of anything would be reading it wrong, and the honest version of this paragraph is that the number is unlabelled in the output and this page will not guess at it.

The two background schedulers, and the one time they ran

Uploads and downloads are handled by their own recorded queues, and the dump prints them with their registration history, which is about as close as this page gets to a receipt:

 + background
   cacheDelete enabled: true
   download scheduler: <l:com.apple.fileproviderd.background-download  registration:<from:2026-11-13 06:41:10 +0000 count:6 to:2026-11-13 06:42:10 +0000> trigger:<from:2026-11-13 06:41:10 +0000> usage:2026-11-13 05:04:40 +0000>
   background downloader pacer: <dirty:false last:1794546081 lastDownloadsAllowedReset:1794546081 totalDownloadCount:0 lastIndexingBarrier: allIndexed>
   speculative disk management: <inGreedyState:true>
   upload scheduler: <l:com.apple.fileproviderd.background-upload-non-expensive  registration:<from:2026-10-20 07:27:09 +0000 count:1>>
 + throttling: no expiration scheduled

The download scheduler was registered six times in a single minute on 13 November, between 06:41:10 and 06:42:10 UTC. That is the one real burst of activity this daemon has had in the window the dump covers, and its shape is worth noticing: six registrations inside sixty seconds, then nothing. The upload scheduler has been registered once, on 20 October, the day this Mac was updated from build 26A428 to 26A434. And the pacer on the next line records totalDownloadCount:0, which means that in the period it tracks, the number of downloads it allowed came to zero. This is a machine whose cloud folder is not being filled from the cloud.

speculative disk management being in a greedy state is the opposite of alarming, and it is worth a sentence. It means the engine is willing to keep local copies of things it thinks you might open, which is the same trade the storage page describes when it explains why available and used can be true at once. It is a policy flag, and on the storage side of this site, the arithmetic that makes a storage bar disagree with the Finder is the thing to read next.

Two other sections of the dump are short enough to quote in full, because their emptiness is informative:

== action operation engine ==
0 operations

apps monitor active
0 apps monitored.

Nothing queued, nothing being watched at the app level. The app monitor is the part that notices a cloud app was deleted while its domain stayed behind, and it has nothing to do because every provider registered here is Apple’s own and none of them can be uninstalled by dragging it to the bin.

The lines that look alarming and are not

Three things in this subsystem read like trouble the first time you see them, and all three are ordinary. This section is here because the alternative is people finding them without a page like this and spending an evening on a symptom.

The first is a block of propagation errors under the throttling heading. There are a handful of lines like this:

 i:fileID(343366) create-item:  last:'1789834411 (-1352h4min)' expired:'1789834411 (-1352h4min)' count:1
   error:'NSError: libfssync.PropagationError 0 "itemChangedDuringPropagation(fileID(343366), reason: "no source item")"'

Read the bracketed age rather than the word error. The last attempt was 1,352 hours ago, which is 56 days, which puts it on 19 September, the day this Mac was set up and the day the domain was created. Each of these has count:1 next to it and an expiry of the same timestamp, which means each of them happened once, long before the dump, and never again. A single failed propagation during the setup of a domain, when files are being copied in while the index is being built, is the expected outcome rather than a fault. What would be concerning is the same item listing a count in the tens or hundreds with a recent timestamp, and that is not what this shows.

The second is the log. Sixty minutes of this daemon’s output is 21 lines, and they are all the same two messages:

2026-11-15 03:12:41.067 Df fileproviderd[1102:2ba1d0f] [com.apple.apsd:connection] <private> Delivering connectionStatusChange from apsd: NO
2026-11-15 03:28:04.923 Df fileproviderd[1102:2ba4329] [com.apple.xpc:connection] [0x7ce3379cc0] activating connection: ... name=com.apple.FileProvider.cache-delete.peer[91022].0x7ce3379cc0
2026-11-15 03:28:04.926 Df fileproviderd[1102:2ba4329] [com.apple.cache_delete:client] <private> role: 64

The first kind is the push connection flapping between NO and YES. This daemon has an interest in Apple’s push service because a cloud provider announces remote changes that way, and apsd tells its clients every time the connection changes state. On a Mac that has been awake for weeks, it changes state regularly, and each flip is two log lines. The second kind is a client connecting to the cache delete door and being assigned a role, which is the storage pressure system asking what it may evict. Both are the daemon being a well behaved citizen. Neither is a symptom.

The third is the throttling heading itself, which has the word no expiration scheduled next to it. In this vocabulary throttling is the engine slowing itself down after a failure, so the phrase to look for is the one that is present: nothing is currently being held back. The entries underneath carry the ancient timestamps explained above. A page about a process would be misleading if it quoted a heading and left out its value.

What Apple’s own documentation says, and the man page that cites a tool that is not installed

The documentation for this one is uneven, and this section says so rather than smoothing it over.

The man page exists, and it is short. On this Mac it is a 442 byte file at /usr/share/man/man8/fileproviderd.8, and the useful paragraphs read in full:

NAME
     fileproviderd - Part of File Coordination

DESCRIPTION
     fileproviderd is the daemon controlling the interaction between extensions and
     filecoordinationd. It is also responsible for coordinating enumeration and property lookup.

     There are no configuration options to fileproviderd, and users should not run fileproviderd
     manually.

Three sentences. The footer dates the page to 11/07/17, which makes it nine years old in a subsystem that has been rebuilt twice since, and nothing about it has gone stale because there was never much to go stale. The phrase Part of File Coordination is the whole design in three words: file coordination is the older macOS service that stops two programs writing the same file at once, and this daemon is the part of it that knows about extensions.

The companion man page, fileproviderctl(1), is more useful, and it lists the four commands the tool has. enumerate walks a provider, materialize writes one item to disk and lists what came out, validate runs the validation suite against a provider, and dump dumps the state of the file provider subsystem, the sync engine and all providers. That is a good, small, honest set of verbs, and it is also the complete list: there is no command for removing a domain, no command for forcing a sync, and no command for resetting an extension. Two of the four write something, and this page only used the one that reads.

The same man page ends with a cross reference that is worth checking rather than trusting, because it does not resolve:

SEE ALSO
     fpck(1)

fpck is the consistency check tool, and the scheduled job earlier in this page names its service half, FPCKService. On this Mac there is no fpck binary in /usr/bin or /usr/libexec, and man fpck returns No manual entry for fpck. Apple’s reference is to a tool that is either shipped only with developer tooling or has been withdrawn, and the man page has not been updated to match. That is a small thing, and this page includes it because it is the kind of small thing that sends someone hunting for a tool that is not there.

The developer documentation is better, and it does name the machinery that matters. Apple’s File Provider framework page explains why the subsystem exists at all, in a sentence that is close to the perfect summary of this page:

An extension other apps use to access files and folders managed by your app and synced with a remote storage.

It then separates the two shapes an extension can take. A replicated extension, available on macOS 11 and later, leaves the system in charge of managing and storing the local copies and asks the extension only to move data and report changes, which is what the iCloud Drive provider above declares when it answers yes to FPFS. A nonreplicated extension manages its own local copy and its own placeholders, which is the older shape. Apple’s own definition of what an extension owes the system is a list of protocols: it must be able to enumerate, it must be able to describe an item and its version, and the system will ask it for both.

The same documentation defines a domain in a way that makes the dump readable: domains partition a provider’s content, so one provider can act as though it were several, and they are how different accounts or locations are kept apart. That is exactly the two iCloud Drive blocks at the top of the dump, one for the domain token and one for the domain’s qualified name, and it is why a person with two cloud accounts sees two folders and one daemon.

What the documentation does not do is name the process. Across the pages read for this piece, Apple’s user facing help never mentions fileproviderd once, and its own pages about syncing a device with a Mac turn out to be about iPhone backups over a cable rather than cloud storage at all. The name appears in Apple’s developer material only in passing. So the pages above, the plist, the entitlements and the daemon’s own dump are carrying almost all of the weight here, and where Apple is silent, this page says so rather than inventing a reason.

Is it malware, and can you turn it off

Not malware, and this is one of the easier ones to demonstrate because there is nothing to interpret. The binary lives in a System framework, is signed under the identifier com.apple.fileproviderd with the platform identifier 26, has no third party team identifier, and carries 66 entitlements, which is the number you expect from something the operating system trusts with other people’s code.

A few of those 66 are worth reading out, because they answer the “why can it do that” questions directly:

EntitlementWhy it is there
com.apple.fileprovider.extension-hostthe daemon hosts the extensions, so it needs the right to run them
com.apple.fileprovider.enumeratewalking folders on behalf of the system
com.apple.fileprovider.resolverresolving an item’s identity and where it lives
com.apple.private.tcc.allow with the Desktop and Documents folder servicesit reads your folders without prompting you, on your behalf
com.apple.private.vfs.dataless-manipulationturning a file into a placeholder and back
com.apple.private.endpoint-security.dataless-manipulationthe same, coordinated with the security layer
com.apple.private.aps-connection-initiatethe push connection, so a provider can be told about remote changes
com.apple.trial.client listing COREOS_FPFS_CONFIG and COREOS_FPFS_SPECULATIVE_DOWNLOADSApple can roll out behaviour to a subset of machines
com.apple.TapToRadarKit.service-accessApple’s internal bug reporter, for its own engineers

That trial.client line closes a loop left open earlier. The end of the dump has a section called Trial configuration with two named blocks, COREOS_FPFS_CONFIG and COREOS_FPFS_SPECULATIVE_DOWNLOADS, each with an empty rollout and an empty experiment dictionary. Those are the two trials this process is entitled to take part in, they are currently handing out nothing, and the empty dictionaries are why. It is a feature flag system wearing an unusual name, and the fact that it appears in both the entitlements and the state dump is a rare case of an Apple subsystem explaining itself.

Can you turn it off? Almost nobody can, and that is the right answer rather than a dodge. There is no preference, no service to unload, no setting. The man page says users should not run it manually, which is the polite version of the same statement. And there is nothing to switch: this daemon is the host for whatever cloud services you have, so the switch that exists is at the level of the services rather than the host. Turn iCloud Drive off in System Settings and the iCloud Drive provider stops asking it for anything, at which point the process sits at zero and waits. Remove a third party cloud app and its extension and that provider disappears from the dump. The daemon itself stays, because the next cloud service you install will need it.

What to do about it

Most of the time, nothing. The numbers in this piece are the argument: 0.023 per cent of one core averaged across 25 days, between 8.6 and 13 MB of memory, 21 log lines an hour at rest, a queue that is counted but not being worked, and a set of schedulers that fired six times in one minute, once, five days before the dump.

There are three cases where an hour of attention is warranted, and the first step is the same in all three.

Ask the daemon which provider is busy, rather than guessing. One command does it, it changes nothing, and it takes a few seconds on a normal machine and longer on a busy one:

$ fileproviderctl dump | head -60

The top of the output names the providers and then the first domain, and the lines to look at are the observers, the enumerators and the indexer counters. If the active enumerator list names the Finder with a folder you have open, or names an app, that is your answer. If the pending indexable count is in the tens of thousands and climbing, an indexing backlog is your answer. And if the download scheduler shows recent registrations, files are moving, which on a first sync is the whole point.

Then, depending on which it is:

If it is enumeration, close the folder. An enumerator belongs to a process, and on this Mac a Finder window showing a large cloud folder was holding three of the four live ones. Closing the window releases them, and there is nothing to kill.

If it is a backlog, let it drain and get out of the way. The queue is worked at utility priority, which means it yields to anything you are doing, so the thing that actually helps is a laptop on a charger with the lid open and nothing else running. A first sync of a large folder or a first index of a new Mac is meant to be busy for hours, and the honest measure of whether it is working is whether the queue is shrinking, not whether the CPU number is high.

If it is a stuck folder in the Finder, the fix belongs to the provider rather than the daemon. A cloud app that has lost its session keeps its domain registered and its folder in place, and the daemon will keep asking it for an enumeration it cannot answer. Apple’s own strings in this subsystem describe the resulting states exactly, and one of them is the line a stuck folder is in: this provider is temporarily unavailable, and syncing will resume when it becomes available again. The way back from that is in the cloud app: sign out and back in, and if it persists, remove the account from the app and add it again.

Two things not to do. Do not killall fileproviderd. It is not kept alive, so it will not come straight back, and the state it was mid way through is not saved for you: the next process that asks for a cloud folder gets a fresh daemon that has to rebuild what it was holding. Nothing catastrophic happens, and nothing is fixed either, because the queue and the extension are still where they were. And do not go poking at the storage folders. They are protected for a reason, and the sizes in the table above are everything you need from them.

One thing to watch for, since the schedule is now known. The consistency check, fpck-repair, runs at most once a day, needs external power, and involves both the daemon and FPCKService. If a Mac on charge overnight becomes warm and loud with no app open, that is a legitimate candidate, and so is the Spotlight queue draining, and so is the background download service moving bytes for something else. The way to tell them apart is the log, where the process names differ.

What this page cannot tell you

The database was measured, not read. The folder returns Operation not permitted to an ordinary account and there is no attempt here to work around that, which is why the four names in the table come from the list of open files rather than a directory listing, and why nothing on this page describes what is inside a row.

Two numbers in the dump are unlabelled and this page does not guess at them. One is the count in parentheses after alive, which fits the shape of an internal tick rather than a population, and the other is error generation: 137, which has no explanation in the output and no counterpart in the man pages. Both are quoted because they are there and you will see them. Neither is used to draw a conclusion.

Which cloud apps you have is the one thing that changes every number on this page. This machine has no third party provider, which is why ~/Library/CloudStorage has nothing in it, why the domain count is two, and why the download counter reads zero. A Mac with two or three cloud apps has more providers, more domains, a longer dump and, quite often, a longer list of things that look like errors. The method transfers and the numbers will not.

And the log limit applies here as much as anywhere in this series. Identifiers arrive hashed, paths arrive as private markers, and the daemon redacts its own output with the brace notation. Counts are trustworthy. Identities usually are not.

All of it comes from one Mac on one build: macOS 27.0.1, build 26A434, M1 Pro, 25 days of uptime. A page about a moving target is only as good as the build it was written on.

Where window managers fit

Nothing here changes how a window behaves, and no amount of sync hygiene makes a desktop easier to work in. The two meet at the same feeling, though, which is a Mac that appears to be doing a great deal you never asked for: hosting extensions, counting a queue, holding folders open for the Finder, deciding what it may evict. That is the invisible half of using a Mac, and windows are the visible half, which usually means a screen full of them and the Dock’s worth of apps behind them.

Ribbon takes the other approach. Windows stay at full size on a single scrolling strip instead of stacking on top of each other, so the window you want is one swipe away and nothing ends up buried behind anything else. 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. You can drive the strip in your browser before installing anything.

The short version

fileproviderd is how macOS shows cloud storage as folders, and it is the host for the extensions that cloud services ship rather than a part of any one of them. Apple’s own man page is three sentences long and says there are no options and that you should not run it manually.

It is started on demand, once, and on this Mac it has never exited. It has no keep alive and no timer of its own, and launchd reports that the reason it is awake is that another process asked it for something. Its two scheduled jobs are a daily telemetry tick at maintenance priority and a consistency check that needs external power and runs at most once a day. It keeps one SQLite database and one staging folder per domain, in a directory macOS will not let you list even though its permissions say you can. On a Mac with no third party cloud app it hosts two providers, Apple’s iCloud Drive and Apple’s Photos, across two domains, and 31 processes were registered as observers of one of them.

Its cost over 25 days was eight and a half minutes of processor time and a dozen megabytes of memory. Its queue read 5,959 items when it was asked, and it was not working them.

The one thing worth remembering is that the process in Activity Monitor is never the thing that is busy. The work belongs to an extension, and there is exactly one command that names it.

Questions

What is fileproviderd on Mac?

It is the daemon that runs File Provider, which is the plumbing macOS uses to show cloud storage as ordinary folders in the Finder. Apple's own man page describes it in two sentences: it controls the interaction between extensions and filecoordinationd, and it is responsible for coordinating enumeration and property lookup. In plain terms, a cloud app ships a small extension that talks to its servers, and fileproviderd is the part of the system that drives that extension and keeps the Finder's picture of the folder correct. Its path is /System/Library/PrivateFrameworks/FileProvider.framework/Support/fileproviderd, which is a symlink to the same binary under /System/Library/Frameworks. On this Mac it used 12.6 MB of memory and 8 minutes 38 seconds of processor time across 25 days of running, and it had been asked for nothing by 31 other processes at once when it was last inspected.

Why is fileproviderd using CPU, memory or network?

Because a cloud folder is being read, written or caught up, and this is the process that marshals that work. It is not a scanner and it has no timer that makes it busy: launchd reports the reason it is awake as ipc, meaning another process knocked. Real work looks like one of four things, and its own state dump names each of them separately. Enumeration is a program walking a folder, often the Finder, and the dump lists the active ones with the pid that asked. Indexing is the queue of items waiting to be handed to Spotlight, and on this Mac that queue read 5,959. Upload and download are the two background schedulers, which fire only for files that are actually moving. The heavy version of all of this is the first sync of a large folder on a new Mac, when the queue is genuinely thousands of items long.

Is fileproviderd a virus or malware?

No. It is Apple's code, signed with the identifier com.apple.fileproviderd and the platform identifier 26, living inside a framework in the System folder where no installer can write. It carries 66 entitlements, which is the sort of list only a system daemon has: it can host extensions, read dataless files, take part in iCloud and push notifications, bypass the folder permission prompts on your behalf, and file a bug report to Apple. The name looks odd for the same reason httpd and sshd do, because it ends in d for daemon, and it is easy to mistake for something you installed when the real answer is that every cloud app you have runs inside it.

Can I stop or disable fileproviderd?

There is nothing useful to stop. It has no configuration options at all, and Apple's man page says in as many words that users should not run it manually. It is not kept alive by launchd, it was started on demand the first time something needed a cloud folder, and on this Mac it has run once since boot and never exited. Force quitting it only means launchd opens it again the next time the Finder or an app asks for something. If you actually want a sync to stop, you stop the sync: sign out of iCloud Drive in System Settings, remove the account from the cloud app itself, or uninstall the cloud app and its extension. The daemon is the stage, not the act.

What is the difference between fileproviderd, bird and cloudd?

fileproviderd is the general one. It hosts the File Provider extensions that any cloud storage service can ship, iCloud Drive is simply Apple's own extension, and it is the layer that turns a folder full of remote items into something the Finder can list. bird is the iCloud Drive daemon specifically, and it is the extension side of that same conversation for Apple's service, which is why the dump names com.apple.bird as the file coordination purpose of the iCloud Drive provider. cloudd is the CloudKit daemon, one layer further out, which syncs the records that many iCloud features keep in step. In a sentence: fileproviderd drives the extensions, bird is the iCloud Drive extension, and cloudd keeps the records that surround them.

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