cloudphotod, the process that syncs your Photos library with iCloud
cloudphotod is the process that keeps your Mac's photo library in step with iCloud Photos. What it is, why it runs, and what to do when sync gets stuck.
By Chethan Kumar S N · Updated
There is a particular kind of search that ends with the same question. Something in Activity Monitor has a name you do not recognise, it has a hammer icon, and the CPU or network column is not at zero. You type the name into a search box, and the answers you get back are split between people telling you it is fine and people telling you to force quit it.
cloudphotod is one of those names. It appears when your Mac is doing something real, which is syncing your photo library with iCloud, and it disappears when that work is done. The confusion comes from the fact that both halves of that sentence are invisible. Nothing in the interface says which process is doing the syncing, and nothing says that a process that has finished is supposed to vanish.
The name itself is not that mysterious. Photo is obvious, and the d on the end is the same old Unix convention that gives you httpd and sshd, meaning a background service rather than something you launched. So it means the background service for cloud photos, which happens to be exactly its job, and it says nothing about a file it is about to delete.
Everything below comes from four places: Apple’s own documentation, the files that ship on disk with the daemon, the log the daemon writes, and read-only checks on the Mac this was written on, a 14 inch MacBook Pro with an M1 Pro running macOS 27.0.1. Nothing was uninstalled, no setting was changed, no photo was opened, and nothing was quit.
What cloudphotod actually is
One command gives you the identity:
$ ps -o pid,ppid,user,%cpu,rss,time,etime,comm -p 6102
PID PPID USER %CPU RSS TIME ELAPSED COMM
6102 1 chethankumar 0.0 4672 0:00.46 05:07:09 cloudphotod
Read it left to right. The parent is PID 1, which is launchd, so the system started it and not an app. It runs as your user account, not as root and not as a hidden account. Its resident memory is 4,672 KB, so about four and a half megabytes, and its processor time is 46 hundredths of a second across five hours and seven minutes of being alive. For comparison, a single scrolling page in a browser will burn more than that in the time it takes you to read this paragraph.
The binary is large, and the size is informative:
$ ls -l /System/Library/PrivateFrameworks/CloudPhotoLibrary.framework/Versions/A/Support/cloudphotod
-rwxr-xr-x 1 root wheel 9990608 Sep 24 12:40 cloudphotod
$ lipo -archs /System/Library/PrivateFrameworks/CloudPhotoLibrary.framework/Versions/A/Support/cloudphotod
x86_64 arm64e arm64e.x1
$ codesign -dvvv /System/Library/PrivateFrameworks/CloudPhotoLibrary.framework/Versions/A/Support/cloudphotod 2>&1 | grep -E "Identifier|Authority|Platform|flags="
Identifier=com.apple.cloudphotod
CodeDirectory v=20400 size=6670 flags=0x0(none) hashes=198+7 location=embedded
Platform identifier=26
Authority=macOS Software Signing
Ten megabytes against the one and a third megabytes of photolibraryd, the process that owns the library. That gap is the whole story of the two processes. photolibraryd has to know about the library files and not much else, and this one has to know about the library files, CloudKit, push notifications, uploads, downloads, thumbnails, shared albums, the conversion services and the retry logic for all of it. The extra eight and a half megabytes are the cost of being the half that talks to a server.
One detail in the identity is worth pulling out, because it is the kind of thing that makes a process look suspicious when it is actually evidence of the opposite. Most of the daemons in this family either have a privileged partner account or nothing at all, and the split is not random:
$ dscl . -read /Users/_cloudphotod
<dscl_cmd> DS Error: -14136 (eDSRecordNotFound)
No such account exists. That matters because of what the alternative would mean. The download daemon nsurlsessiond runs a second copy as a user called _nsurlsessiond, because some of the jobs it handles belong to apps rather than to people. Photo syncing does not work that way. Every photo library on a Mac belongs to a person who is signed in to an Apple Account, so the daemon runs as that person, holds that person’s credentials through the keychain, and asks the system for permission like anything else would.
Its keychain access is specific rather than general, too. The entitlements list includes one access group, com.apple.photos.client-side-encryption-manager, and one iCloud service, CloudKit. It is not carrying a key that opens everything.
The one that moves things, not the one that owns them
The easiest way to understand this process is to line up the two halves of Photos and see where the line falls.
photolibraryd opens the library, migrates it after a system update, registers the background jobs, tells Spotlight what is in there, and answers when macOS asks how much space the library could give back. It does that on the Mac, locally, whether or not you have ever signed in to iCloud. cloudphotod does the other half. It takes what photolibraryd has written down and moves it to the server, and it takes what the server has and writes it back.
That division is visible in the log, and so is the fact that they work as a pair. When the sync engine has an upload to prepare, a log line names the process on the other side of the handoff, and when a background task comes due it names photolibraryd as the involved process:
"InvolvedProcesses" => {
"0" => "photolibraryd"
}
That snippet is from cloudphotod’s own launch agent, in the task called com.apple.cloudphotod.periodic.upload.computestates. It is the sync daemon describing, in Apple’s own file, that this particular job involves the library daemon. Nobody had to guess.
There is a bigger version of the same idea later in this page, and it is the single best artefact in the whole family, so it is worth knowing it exists before you go looking for it. The fast pass task inside the same launch agent carries a list of six processes, and those six are the complete cast of the iCloud Photos pipeline, written down by Apple.
Where its books are kept
Here is the thing nobody tells you about iCloud Photos. The sync engine is not a service with a folder of its own somewhere in your Library. Its database lives inside your photo library, in a subfolder the filesystem marks as not for indexing.
$ lsof -p 6102 | grep cloudphoto
cloudphotod 6102 chethankumar 3r DIR 1,16 384 67405 /Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex
cloudphotod 6102 chethankumar txt REG 1,16 32768 350119 /Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex/storage/store.cloudphotodb-shm
Follow that path. Inside Photos Library.photoslibrary there is a resources folder, and inside that a cpl folder, and inside that a folder called cloudsync.noindex. The suffix is a Finder and Spotlight convention, the same one that keeps your node_modules out of search results, and here it means the sync engine’s own files are deliberately excluded from indexing. Inside is a storage folder holding the database, and the database is called store.cloudphotodb.
On this Mac there were two of them, and that is not a mistake either:
$ lsof -p 6102 | grep cloudphotodb
/Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex/storage/store.cloudphotodb-shm
/Users/chethankumar/Library/Photos/Libraries/Application/com.apple.VisualIntelligence/00000000-0000-0000-0000-000000000001.photoslibrary/resources/cpl/cloudsync.noindex/storage/store.cloudphotodb-shm
The first is the system photo library, the one in your Pictures folder. The second belongs to an application library under ~/Library/Photos/Libraries/Application/, in this case one for Visual Intelligence, which is the feature that looks up what is in a photo. Application libraries are how macOS gives a feature its own small library without giving it yours. Both get synced, so both get a sync database, and the daemon holds both open at once.
Listing inside those folders does not work, and the exact wording of the refusal matters:
$ ls "/Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex/storage/"
ls: Operation not permitted
$ stat -f "%N %z bytes" "/Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex/storage/store.cloudphotodb-shm"
/Users/chethankumar/Pictures/Photos Library.photoslibrary/resources/cpl/cloudsync.noindex/storage/store.cloudphotodb-shm 32768 bytes
Operation not permitted, not permission denied. That distinction is the difference between a privacy layer and a Unix permission bit: the system is declining to let a terminal read a protected folder, while still telling you the file’s size when asked for it directly. It is the same wall you hit on ~/Library/Photos, and it is meant to be there. Your photos, and the database that describes them, are not readable by whatever happens to be running in Terminal.
What starts it, written in one file
Most of the mysterious process questions people actually have are not questions about the code. They are questions about what caused it to run at nine in the morning, and the answer is almost always a file. This daemon’s file is /System/Library/LaunchAgents/com.apple.cloudphotod.plist, all 4,102 bytes of it, and it fits on one screen.
Four background tasks are registered in it. Every one is gated, and the gates are the interesting part:
| Task | Interval | Gates |
|---|---|---|
configurationrefresh | 12 hours | network, user idle |
initialdownload.fastpass | one shot | network |
maintenance | 24 hours | external power, user idle, Power Nap |
periodic.upload.computestates | 5 hours | none |
Read the last column as a sentence about when you will see this process. The configuration refresh runs twice a day when the network is up and you have stopped touching the keyboard, and it is the one that fetches whatever the server thinks the rules should be now. It is the task that produces the log line about how long ago the configuration was last updated. The fast pass is a one shot, fired when a library needs its initial contents pulled down from iCloud, and it is the task that carries the six process list. Its completion is also a starting gun elsewhere: the knowledge graph daemon registers this fast pass as a dependency before its own first pass, so the work of understanding your photos waits until the photos have fully arrived. The daily maintenance run is the only one that demands external power, which is why a plugged in Mac behaves differently from one on battery, and Power Nap means it can happen while the machine is asleep. The compute states upload runs every five hours with no gate at all.
Alongside those four there are also five mach services, which is the other way this process gets started:
"MachServices" => {
"com.apple.aps.photos.cloud.datarepair" => true
"com.apple.cloudphotod" => true
"com.apple.cloudphotod.daemon" => true
"com.apple.photos.cloud.pushnotification" => true
"com.apple.photos.cloud.pushnotification.dev" => true
}
Mach services are names other processes can call. Four of these five are about being reached: two for push notifications, one for the repair path, and one for the daemon interface that Photos itself uses. The fifth is the plain service name. Push is the one that produces the behaviour people notice, because it means a photo taken on your phone can wake this daemon on your Mac within seconds, with no timer involved.
And there is a fifth trigger that is not a service at all, but a doorbell:
"com.apple.distnoted.matching" => {
"Launch Daemon" => {
"Name" => "com.apple.cpl.wantsdaemon.notification"
}
}
That is launchd watching the distributed notification system for a message called com.apple.cpl.wantsdaemon.notification, and starting this process when one arrives. Something on your Mac can simply ask for the sync daemon by posting a notification with that name, which is how a part of Photos that is not the daemon can request that the daemon exist.
What it did in the last 24 hours
The daemon keeps a log, and the log is the only honest answer to the question of what it has been up to. On this Mac, in one 24 hour window:
$ log show --predicate 'process == "cloudphotod"' --last 24h --style compact | wc -l
2287
2,287 lines is not a lot for a daemon, and the first thing the lines tell you is that there were five separate runs rather than one long one. The process IDs in order, with the window each covered:
$ log show --predicate 'process == "cloudphotod"' --last 24h | grep -oE 'cloudphotod\[[0-9]+'
PID 88793 Nov 13 19:59 to 20:00 15 seconds
PID 11845 Nov 13 23:02 to Nov 14 08:19 9 hours 16 minutes
PID 78541 Nov 14 08:35 to 08:41 5 minutes 53 seconds
PID 81716 Nov 14 09:02 to 11:10 2 hours 8 minutes
PID 6102 Nov 14 12:01 onwards still alive
That shape is the correct shape. It starts when there is something to do, it works, and then it stops existing. Nothing about it is meant to be a permanent resident, and any advice you read about keeping it alive is advice against how it was designed.
The second thing the log tells you is what a session actually does. When a sync session begins, it walks a fixed list of phases and announces each one as it moves. Filter for the word “moved” and the whole state machine falls out, 78 transitions in this window, 13 distinct phase names, six complete passes:
$ grep -oE 'moved to [a-z-]+' <log> | sort | uniq -c | sort -rn
6 upload-compute-states
6 update-transport
6 setup
6 scope-update
6 resources-download
6 reshare
6 push-highpriority
6 push
6 pull-scopes
6 pull
6 process-staged-scopes
6 mingle
6 cleanup
Six of each means six sessions ran start to finish; a session that died partway would leave the counts uneven, and uneven counts are exactly what to look for if you are the sort of person who enjoys having a real diagnostic instead of a guess.
The names are worth reading properly, because they are the plainest description of this process anywhere. setup prepares. scope-update refreshes what parts of the library it is responsible for. push and push-highpriority send local changes up, with the second one reserved for the changes that cannot wait. reshare deals with shared albums. pull and pull-scopes take changes down. process-staged-scopes handles the scopes that arrived mid-session and had to be parked. mingle is where local and remote changes are reconciled. resources-download fetches the actual image and video data. upload-compute-states uploads the small derived data that lets a device describe an image without sending it. update-transport refreshes the connection. cleanup is cleanup.
Alongside the phases, the log carries the ordinary state of the account:
[com.apple.photos.cpl:engine.transport.cloudkit] Account status is Available
[com.apple.photos.cpl:engine.transport.cloudkit] Walrus is disabled
[com.apple.photos.cpl:engine.scheduler] There is no changes in the pull queue and no staged sync anchors
[com.apple.photos.cpl:configuration] Loaded configuration ... Last update was 12 hours 35 min ago
Available is the good answer. The middle line is the one that answers a question people ask constantly after the machine has been sitting idle: no changes in the pull queue means the server has nothing new for you, which is the correct state, not a stalled one. And the configuration line is a timestamped receipt for the twelve hour task above, saying when the rules were last refreshed.
The limits are written down too
There is a second file, and it is the most useful one on the page if you have ever wondered why a large library uploads at a particular speed. /System/Library/PrivateFrameworks/CloudPhotoLibrary.framework/Versions/A/Resources/cloudphotos-1.0.plist is the engine’s own settings file, and it is not obfuscated in any way:
"max.num.photosToImport.hourly" => 5000
"max.num.photosToImport.daily" => 50000
"max.num.recordsToUploadPerBatch" => 200
"max.num.resourcesToUploadPerBatch" => 8
"max.num.resourcesToDownloadPerPush" => 30
"refresh.interval.seconds" => 7200
"max.days.inRecentlyDeleted" => 30
"client.request.throttle" => {
"start-after" => 2
"wait-at-least" => 2
"wait-at-most" => 60
"give-up-after" => 1800
"forget-after" => 3600
}
This is the mechanism behind a complaint you have probably seen or made. Eight resources per upload batch is not a mistake and it is not a slow connection, it is a deliberate ceiling, and it is why a first sync of a large library is measured in hours rather than minutes. Five thousand imports an hour and fifty thousand a day are the ceiling on how fast the engine will take photos in. Thirty resources per push download is why a device that has just been set up fills in gradually. The refresh interval of 7,200 seconds is the two hours between configuration checks. And the throttle block is the engine’s own backoff policy: it starts carefully, waits at least two seconds and at most a minute between attempts, gives up on a request after half an hour, and forgets the whole thing after an hour.
The same folder holds a second file worth one line, CPLSchema-com.apple.photos.asc.e2ee.plist, which is the schema for advanced data protection. It is 7,209 bytes and it opens with two settings that answer a privacy question directly:
"cloudkit" => {
"encryptAllResources" => true
"forceMMCSv2" => true
Everything in the resources is encrypted, and the engine is forced onto the modern asset transfer protocol. The long list of keys underneath is the field by field mapping between the library’s records and their encrypted counterparts, all 200 odd of them, each one paired with an encrypted name.
Why it uses CPU, and why it uses network
Both questions have the same answer, and the answer is that this is not a maintenance daemon. It does not wake up to tidy caches or rebuild indexes. Every time it runs, something moved.
The three things that wake it are a push notification, one of the four background tasks, or another process asking for it by name. All three of those exist because the library changed somewhere. A photo taken on your phone. An edit you made on an iPad. An album you shared. A deletion. A new device signing in and needing the whole library.
So when you see it high in the CPU column, it is doing one of a small set of jobs: preparing uploads, working through a queue of downloads and writing the results into the library, reconciling a large set of changes that accumulated while the Mac was off, or running the repair path on a library that came back inconsistent. The one that takes longest, and by a wide margin, is a first sync after turning iCloud Photos on. Apple says so on the page that explains the feature, in one sentence: when you first turn on iCloud Photos, it can take a while to upload your photos to iCloud, and you can continue to use Photos while your photos are being uploaded.
That sentence is the most useful thing Apple has published about this process, because it tells you the expected behaviour is a long, slow, visible upload rather than a fault.
There is one thing worth checking before you blame the daemon, though, and it is the reason the daemon looks stuck when it is not. If the Mac is short of space, it will not download originals, and if the network is metered or the machine is asleep, the tasks gated on those conditions simply do not run. The daemon is not ignoring you; it is waiting for a condition that its own launch agent told it to wait for.
When iCloud Photos actually gets stuck
Everything above describes normal. The practical question is what to do when it is not normal, and here the honest answer is that a stuck sync has a small number of causes and the fix is usually nowhere near this process.
Start with the setting, in Photos: Photos menu, then Settings, then the iCloud tab. If you see a status rather than a tickbox, read it before doing anything else. Apple’s own iCloud Photos page lists the two options you can choose between and what each one means: Download Originals to this Mac keeps the full size versions on the Mac as well as in iCloud, and Optimise Mac Storage keeps smaller versions locally when space is limited and leaves the originals in iCloud, downloading them again on demand. Most reports of photos that will not download turn out to be the second setting doing precisely what it says.
Then check space, in both directions. Full on the Mac and the downloads have nowhere to land. Full in iCloud and the sync pauses with a message rather than an error, and the fix is on Apple’s storage page rather than on the Mac: your Apple Account, then iCloud, then Manage, where each app’s usage is listed separately and a plan change is one click away.
Then check the Apple Account itself, because both daemons in this pair need a signed in account and both will sit quietly without one. The same launch agent string appears in the interface when it is missing, and Apple’s phrasing is worth quoting because it is precise: to use iCloud Photos you must be signed in to your Apple Account in System Settings.
If all three of those are fine and the sync is still stalled, the repair path is a real thing rather than a ritual. The daemon has a mach service named exactly for it, com.apple.aps.photos.cloud.datarepair, and the honest advice is not to call it yourself. Sign out of iCloud Photos on the Mac and back in, which is Apple’s documented flow: deselect iCloud Photos in Photos settings, and choose Download to keep the photos on the Mac, then tick the box again. That rebuilds the sync state from scratch, which is the same thing a repair does, using an interface that is designed for people.
And then the unglamorous answer. A library of any size has a genuine backlog, and eight resources per upload batch is the ceiling no amount of restarting will raise. If the upload is moving, even slowly, the correct action is to leave the machine plugged in and closed overnight and check the count in the morning.
Can you stop it?
This is the part where the advice you find online is not just wrong but inverted, because the usual advice is to force quit it, and there is nothing to force quit.
Look at the launch agent again. There is no KeepAlive key in it at all, unlike photolibraryd, which sets KeepAlive for the crashed case so that launchd brings it straight back. What this agent does have is the opposite instruction:
"EnablePressuredExit" => true
"POSIXSpawnType" => "Adaptive"
EnablePressuredExit means the system is allowed to end this process when memory is tight, and Adaptive spawn type means it is launched in a form that expects to be ended. The launchd record says the arrangement is working exactly as intended:
state = running
runs = 30
forks = 0
execs = 1
immediate reason = xpc event
last exit reason = JETSAM_REASON_MEMORY_IDLE_EXIT
The last line is the one to read twice. The previous run of this process ended because the memory system decided it was idle and reclaimed it, which is a deliberate act by macOS and not a crash. If you have ever opened Activity Monitor, seen the process, looked away, and found it gone, that is what happened, and it is normal.
So force quitting a running instance does not disable anything. It ends a session that is doing the only job it has, and the next push notification or background task starts a new one. The only switch that changes behaviour is upstream: the iCloud Photos tickbox in Photos settings, which stops syncing at the source. Below that there are two softer levers, both of them honest. Staying on battery suppresses the tasks gated on external power, so the daily maintenance run will not fire. And having a huge library is a decision not to upload a huge library, which is a fact rather than a tip.
Apple never names it
Across every Apple page fetched for this article, including the Photos User Guide page for iCloud Photos, the Mac User Guide page for managing iCloud storage, the storage optimisation page and the topic index, the string cloudphotod appears zero times. Apple documents the feature and never documents the machinery, which is the same position they took on the other daemons in this family.
The feature description is worth quoting, because it is what the process is for, written in the language of a person rather than a log:
With iCloud Photos, all the photos and videos in your photo library are stored in iCloud, so you can access them from your Mac, iPhone, iPad, Apple TV 4K, Apple Vision Pro or PC, and on iCloud.com.
And the privacy position is short and unambiguous, in the Photos and Privacy document:
iCloud protects each photo and video file, along with the file’s metadata, by encrypting it in transit and at rest.
Two things follow from those quotes and both are worth holding at once. The syncing is the product, not an accident, and it is encrypted while it happens.
The rest of the cast
If you got here because of a process name in Activity Monitor, you have probably already met one or two of the others. The six process list in this daemon’s own launch agent is the best map of the family, so it is worth walking through it once.
cloudphotod is this page. nsurlsessiond is the general purpose background transfer service that carries the actual bytes on behalf of everything, and it keeps a folder of one subfolder per bundle identifier it has ever worked for. cloudd is CloudKit’s own daemon, the layer underneath the sync engine that talks to the server. The Photos video conversion service and the Photos image conversion service are the two that produce the smaller versions of your photos and videos, which is why a big import briefly pegs several cores. And photolibraryd is the one that owns the library on disk and writes everything the others decide into it.
Put them in order and it reads like a sentence. Something in the library changes, photolibraryd records it, cloudphotod decides what the server needs to hear about it, cloudd puts it on the network, nsurlsessiond moves the bytes, and the conversion services build the versions the other devices will actually look at.
One measured comparison is worth carrying away from all of this. On this Mac, at the same moment, cloudphotod was using 4,672 KB of memory and less than half a second of processor time, while the media analysis daemon was sitting on 15,504 KB and three minutes and ten seconds of processor time. The sync engine is not the expensive one. Syncing is a small amount of bookkeeping wrapped around a lot of waiting.
Where window managers fit
Nothing on this page is a window problem and it would be dishonest to pretend otherwise. A daemon that moves files between a Mac and a server is doing real work, and the fact that it is cheap most of the time does not make it a fault to be hunted.
The other kind of slowness is different. It is the kind where the machine is fast and the screen is still the thing you are fighting, where twenty windows sit on top of each other in the corner of one display and the app you want is somewhere in the pile. That is not a background process and it will not show up in Activity Monitor, because it costs you attention rather than processor time.
Ribbon replaces the stacking with one rule: windows stay at full size on a scrolling strip, and the one you want is a swipe away instead of buried. 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
cloudphotod is the process that moves your photo library between your Mac and iCloud. It runs as you, from a ten megabyte binary inside a System framework, signed by Apple. It has no system account of its own, no KeepAlive in its launch agent, and an explicit instruction that the memory system may end it when it goes idle. It started five times in the last 24 hours on this Mac, ran for between 15 seconds and 9 hours, and used less than half a second of processor time in its current run.
Its database lives inside your photo library, in a folder called cloudsync.noindex that Spotlight is told to ignore, in a file called store.cloudphotodb, and there is one per library so an application library gets its own. Its limits are written down in a 2,236 byte file in its own framework: eight resources per upload batch, two hundred records per batch, five thousand imports an hour, fifty thousand a day, a two hour configuration refresh, and a throttle that gives up on a request after half an hour.
What wakes it is a push notification, one of four background tasks, or another process asking for it by name. What to do about it is usually nothing, and when it is something, the lever is the iCloud Photos tickbox rather than the process. And the one sentence that explains every complaint about a first sync is Apple’s own: when you first turn on iCloud Photos, it can take a while to upload your photos to iCloud.
Questions
What is cloudphotod on my Mac?
It is the sync engine for iCloud Photos. Its path is /System/Library/PrivateFrameworks/CloudPhotoLibrary.framework/Versions/A/Support/cloudphotod, it is signed by Apple, and it runs as your own user account with no hidden system account behind it. Its job is to move your library between your Mac and iCloud in both directions: uploading new photos and edits, downloading originals you have not got yet, keeping albums and shared albums in step, and repairing a library that has fallen out of step. On this Mac it was using 4,672 KB of memory and had used less than half a second of processor time across five hours of running.
Why is cloudphotod running and using CPU or network?
Because something is being synced. It does not idle in the background all day: on this Mac it started five separate times in 24 hours, ran for as little as 15 seconds and as long as 8 hours 45 minutes, and then went away. When it runs, it goes through a fixed sequence of thirteen named phases, and the network traffic you see in Activity Monitor is the upload and download work of those phases. If it is busy for a long stretch, the honest answer is that a large library takes a long time to upload, and Apple says so on its own iCloud Photos page.
Is cloudphotod a virus or malware?
No. It lives inside a framework in the System folder, it is signed by Apple under the authority macOS Software Signing, its identifier is com.apple.cloudphotod, and it is a universal binary carrying three architectures. It also has no user account of its own, which is worth a sentence: the download daemon nsurlsessiond runs a privileged copy as _nsurlsessiond, and no _cloudphotod account exists. The reason the name looks alarming is that a one word process with a d on the end is exactly how something nasty would be named, except that something nasty could not live in the System folder.
Can I stop or disable cloudphotod?
There is nothing to stop, because there is nothing running the rest of the time. Its own launch agent has no KeepAlive, it is set to let the system reclaim it when memory is tight, and launchd starts it on demand when a push arrives, when a background task comes due, or when another process asks for it by name. Force quitting it on a running Mac just means it opens again the next time a photo changes somewhere. The switch that actually matters is in Photos: Settings, then iCloud, then the iCloud Photos tickbox. Turning that off stops the sync side, which is the whole thing.
What is the difference between cloudphotod, photolibraryd and photoanalysisd?
cloudphotod moves your library between the Mac and iCloud. photolibraryd owns the library itself on disk and is the only process allowed to open it. photoanalysisd and mediaanalysisd are the analysis half, which looks at the pictures to build People and Pets, Memories and search. The clearest proof is an Apple file rather than a description: the fast pass task inside cloudphotod's own launch agent lists the processes it works with by name, and the list is cloudphotod, nsurlsessiond, cloudd, the Photos video conversion service, the Photos image conversion service and photolibraryd. All six are real, and none of them is a problem to have.
Ready? Buy Ribbon for $15, or read all the guides.