sharingd, the daemon that introduces your Mac to everything nearby
The Mac daemon behind AirDrop, Handoff and Instant Hotspot: what it advertises nearby, why the firewall and keychain ask about it, and what its logs say.
By Chethan Kumar S N · Updated
Your Mac is always a little bit famous. Walk into a room with an iPhone in your pocket and the two machines notice each other, quietly, dozens of times a minute. The Mac side of that conversation is run by one process: sharingd.
The name makes it sound like a small utility. It is not. This is the daemon behind AirDrop, Handoff, Instant Hotspot, the share sheet and the Finder’s awareness of shared computers, and on the Mac used for every measurement in this article it had been running for twenty-six days straight without restarting once, on about one minute forty seconds of processor time per day. It is one of the cheapest daemons on the system for the amount of machinery it runs.
What the manual actually says
Most of the daemons in this series have manuals that range from two sentences to nothing at all. sharingd’s is a page with a real description, and it has not changed since it was written:
Sharing Daemon that enables AirDrop, Handoff, Instant Hotspot, Shared Computers, and Remote Disc in the Finder.
The file, /usr/share/man/man8/sharingd.8, is dated December 15, 2012, and its history section says the daemon first appeared in Mac OS X 10.9 and iOS 7. Thirteen years on, the sentence still covers the whole job. The second paragraph adds one detail worth stopping on: the daemon “is used by the Finder to enable AirDrop file sharing, Handoff between iCloud devices, Instant Hotspot discovery, connecting to shared computers, and accessing Remote Discs from other computers.”
Used by the Finder. That is the cleanest way to understand what sharingd is. It is not the file server, not the screen server, not the network stack. It is the greeter. Other daemons do the serving once a connection exists. sharingd’s work is making the connection happen: advertising what this Mac can do, listening for what nearby devices can do, and marrying the two up in the Finder’s sidebar, in AirDrop’s share sheet, in the Handoff row that appears when you pick up your iPhone.
You can verify every claim in this paragraph yourself:
man sharingd
ls -l /usr/share/man/man8/sharingd.8
The measurements
Everything below was measured read only, on one Mac: macOS 27.0.1, an M1 Pro with ten cores, twenty-six days and nine hours past its last boot.
ps -Awwo pid,ppid,user,%cpu,rss,etime,time,args | grep [s]haringd
1057 1 chethankumar ... 26-09:10:10 44:17.33 /usr/libexec/sharingd
Read that the way the series has learned to. Process 1057, parent 1, so launchd started it. The user is not root: sharingd runs as you, the logged in user, the same as rapportd and unlike the root daemons like bluetoothd and sandboxd covered earlier. That makes sense for a daemon whose whole job is per person features. Your AirDrop identity, your contacts, your hotspot. There is no system wide sharingd on a Mac, only per session ones.
Processor time is 44 minutes 17 seconds across 26.4 days, which is about 1 minute 41 seconds a day, or a tenth of one per cent of a single core. Memory sits at 27,376 KB, roughly 27 MB, comfortably under the 70 MB soft memory ceiling launchd has set for it. This is not a daemon that costs you anything.
The binary itself is telling. /usr/libexec/sharingd is 16,293,088 bytes, and it ships in arm64e and arm64e.x1 slices only, with no Intel slice at all, the second daemon in this series after sandboxd where Apple has stopped shipping x86. Its code signature reports Identifier=com.apple.sharingd and Platform identifier=26, the platform flag Apple reserves for the operating system’s own files, and its string table runs to 26,560 entries. A daemon whose documentation is one page carries a vocabulary of twenty six thousand strings, because folded inside it are the whole feature surfaces of AirDrop, Handoff, tethering, Classroom transfers, AirPlay reception and keychain sharing.
The identity commands, verbatim
ps -Awwo pid,ppid,user,%cpu,rss,etime,time,args | grep [s]haringd
ls -l /usr/libexec/sharingd
lipo -archs /usr/libexec/sharingd
codesign -dv /usr/libexec/sharingd
strings -a /usr/libexec/sharingd | wc -l
One launch job, fifteen doors
Some daemons in this series take three separate launchd jobs to describe. sharingd takes exactly one: /System/Library/LaunchAgents/com.apple.sharingd.plist, 1,487 bytes, a per user agent with KeepAlive true, RunAtLoad true, and LimitLoadToSessionType set to Aqua, meaning it lives in your graphical session and restarts the moment it dies.
What the plist really holds is a cast list. sharingd registers fifteen Mach services, and reading them is like reading the feature list of the last decade of Apple device integration:
| Mach service | What it is |
|---|---|
| com.apple.sharing.airdrop.service | AirDrop itself, sending and receiving |
| com.apple.sharing.handoff.advertising | Broadcasting this Mac as a Handoff target |
| com.apple.sharing.handoff.scanning | Watching for other devices’ Handoff beacons |
| com.apple.sharing.sharesheet | The system share sheet and its recipients |
| com.apple.sharing.transfer-observer | Watching transfers through to completion |
| com.apple.sharing.classroom-transfer | The Classroom app’s managed AirDrop lane |
| com.apple.sharing.collaborationuserdefaults | Shared collaboration state for files |
| com.apple.sharingd.pairedcontactmanager | Contacts of paired devices |
| com.apple.AutoUnlock.AuthenticationHintsProvider | Apple Watch unlock hints, a service it shares with rapportd |
| com.apple.coreservices.appleid.aps | Push notifications for your Apple Account |
| com.apple.StatusKit.local.client | Publishing what the Mac is doing |
Two of those deserve a word. classroom-transfer is the lane schools use: the daemon’s own string table names a handler SDAirDropReceiveClassroomHandler.swift and links against ClassroomKit, so managed AirDrop in classrooms rides this same process. And AutoUnlock.AuthenticationHintsProvider appears in both sharingd’s plist and the rapportd system daemon’s, which tells you the Apple Watch unlock feature is important enough to be reachable through two daemons at once.
The launchctl state adds the schedule, and it is almost nothing:
launchctl print gui/$(id -u)/com.apple.sharingd
state = running
runs = 1
last exit code = (never exited)
immediate reason = ipc (mach)
One run, no exits, since boot. And exactly one timer in the entire job: a repeating event called com.apple.sharingd.airdrop.nearby-sharing-metric-daily, an Interval 86400 maintenance task that files one AirDrop metrics report a day. Everything else the daemon does is reactive. Something pings it, it answers.
One more contrast worth knowing: the plist sets EnablePressuredExit to false. When memory gets tight, launchd reclaims daemons that opt in, like cloudd, and restarts them later. sharingd has explicitly opted out. A daemon whose job is to be instantly reachable when your iPhone appears cannot afford to be asleep, so it stays resident.
What it actually does all day
A quiet hour of sharingd’s log is nothing like quiet. Over thirty measured minutes, with nobody sharing anything, the daemon wrote 4,169 log lines. The breakdown by subsystem:
| Subsystem | Lines in 30 minutes |
|---|---|
| SDNearbyAgentCore | 1,262 |
| WirelessProximity (via bluetoothd) | 491 |
| SFBLEScanner | 399 |
| contacts api-triage | 130 |
| Handoff | 98 |
| TetheringAgent | 90 |
| login SA_General | 64 |
| xpc connection | 61 |
| AirDropHashStore | 48 |
| SFProximityEstimator | 23 |
| BLEAdv | 19 |
And the single biggest thing in the log, bigger than everything except the scan machinery itself, is one device.
The phone on the desk, ranged a thousand times
1,076 of those 4,169 lines, just over a quarter of everything the daemon said in half an hour, are the same sentence, repeated about 36 times a minute:
Unable to decrypt activity level with authTag no identity yes error 0 for device SFDevice ID bb00bf2d-…, IDS BBlxPzaF, RSSI -46 (-44)*N, … PairedBT, PairedSys Conjectured, rapportID BBlxPzaF, DF 0x28 < MyiCloud Ranging >, DT Generic, AcLv ? (16)
Decode it and you get a small story. The flag field literally reads MyiCloud Ranging: this is the proximity ranging between your own iCloud devices. The received signal strength runs -43 to -46 dBm, which for Bluetooth is a device within a metre or two, an iPhone sitting on the desk next to the Mac. The Mac can see the phone is there, knows it is paired, knows it is family, and cannot decrypt the field that says what the phone is doing, AcLv ?, because the phone has not shared it. So it asks again. Thirty six times a minute, all day, the Mac checks whether the phone in your pocket is still the phone in your pocket.
Every identifier in that line is redacted, the BB... prefixes, and that is worth saying plainly: Apple’s unified logging anonymises your own device names, even from you, unless you unlock the private data with your credentials. The daemon knows your devices; the log refuses to gossip about them.
The rest of the half hour is the supporting cast. 801 lines of resolving Finder bookmark data, which is the Shared Computers half of the man page’s promise, keeping the sidebar’s list of machines you can reach warm. 122 keychain lookups, which the FAQ below comes back to. And the TetheringAgent, whose log lines read like a cockpit instrument for a paired iPhone:
CompanionLink changed: IDS ‘BBjAdHom’, Nm ‘BBinAeiv’, AcLv = Screen (7), … SF 0x8000880382 < BLE Personal DuetSync WiFiP2P Owner ApplePay AirDropUsable >
That one line, logged whenever the phone changes state, tracks whether it is Idle, Screen on, or in User’s hands, and lists its capabilities: it will do BLE, it will do Wi-Fi peer to peer, it can be a hotspot Owner, it can AirDrop. This is the table behind Instant Hotspot, the reason your phone’s internet connection appears in your Wi-Fi menu before you have asked for it. Nothing connected during the half hour measured. The daemon was simply keeping the roster current.
The census commands
log show --last 30m --predicate 'process == "sharingd"' --style compact > /tmp/sharingd.log
wc -l /tmp/sharingd.log
grep -c "MyiCloud Ranging" /tmp/sharingd.log
grep -c SecItemCopyMatching /tmp/sharingd.log
The 30 minute window is deliberate. A full hour of sharingd on a busy Mac can run to double the load and the command slows down with it.
Why the firewall asks about it
Search for sharingd and you quickly meet the firewall prompt: do you want sharingd to accept incoming network connections? The question sounds alarming. The reality is dull, and it is worth separating what the daemon holds open from what it does not.
On the Mac measured here, sharingd held no TCP listener at all. Zero. What it holds is UDP: one socket bound to all interfaces, one on port 59960, and a web of IPv6 link-local conversations, those fe80: addresses, which are the private addresses devices use to talk to other devices on the same link without a router ever being involved. That is the AirDrop and Continuity transport: peer to peer, local, over the special Wi-Fi channel (AWDL, which the binary references 198 times) and Bluetooth LE, with bluetoothd doing the radio work on the BLE side.
The application firewall sees a process binding sockets other machines can send to, and asks. The honest answer is to allow it. The binary is platform signed Apple code, the sockets are how every share you have ever done arrived, and blocking it costs you incoming AirDrop while buying you nothing. If the prompt recurs after every restart, the setting lives in System Settings, under Network, Firewall, in Options.
The contrast with the series is instructive. bluetoothd and rapportd both draw the same prompt, and all three daemons are layers of the same handshake: bluetoothd drives the radio, sharingd runs the features and the hashing, rapportd carries the session once devices agree to talk. Three daemons, three prompts, one ecosystem.
Why it wants the login keychain
The other prompt sharingd is famous for is the keychain one: sharingd wants to use the login keychain. This one has a simple cause and a slightly longer story.
The cause: the daemon reads keychain items as part of its normal work, and the logging proves the pace. 122 SecItemCopyMatching calls in the measured half hour, on a Mac where nothing was being shared. Its string table carries the other half: it adds certificates it receives to the keychain, and it ships a whole alert family for iCloud Keychain trouble, with strings for Keychain UUID, Keychain Devices and Keychain Items. AirDrop identity, Handoff keys, iCloud Keychain verification codes, they all live behind that login keychain.
So when macOS interposes and asks whether sharingd may use the keychain, usually after you changed your login password, or after a restart where the keychain has not been unlocked for a background process yet, the prompt is the system doing its job, not an attack. Allow it. Denying it permanently just wedges AirDrop and Handoff until the next prompt.
Contacts Only, explained by the daemon itself
The same keychain-adjacent machinery answers a question people ask about AirDrop constantly: what does Contacts Only actually check?
sharingd maintains a hash store for exactly this, and its log lines are disarmingly plain about how it works: Begin AirDropContactHashManager OSTransaction. CDB: store loaded. And when your contacts change: Change event is DropEverything. Request regenerate entire db. The binary’s strings name the contents: Validated Phone Hashes, Validated Email Hashes. Your Mac hashes every phone number and email address in your contacts, and when another device announces itself nearby, what it announces is hashed versions of its owner’s identifiers. Contacts Only means: the two hash lists have to match. No device ever sees your contacts, and no contact list ever leaves your Mac, only the hashes do, and hashes are one way.
Apple’s own wording, from the AirDrop page in the Mac User Guide: AirDrop “lets you share instantly with people nearby”, and “Transfers are encrypted for security, and the recipient can accept or decline each transfer as it arrives.” The same page adds two practical facts people miss: devices need to be within about 10 metres, and if you walk out of Bluetooth and Wi-Fi range mid transfer, the transfer continues over the internet. That last one is newer than most people’s mental model of AirDrop, and it is why a large AirDrop does not die when you leave the room.
The settings pane, whose strings live on disk in AirDropHandoffExtension.appex, lists the discoverability options verbatim: No One, Contacts Only, Everyone, and a fourth newer one, Known AirDrop Contacts, described as “You will automatically appear for 30 days to people you have shared a one-time code with.” The same pane carries the Handoff switch, “Allow Handoff between this Mac and your iCloud devices”, and the reminder that “Handoff is required to move your cursor and keyboard to a nearby Mac or iPad”, which is Universal Control talking.
The sleep question
A recurring search phrase is sharingd preventing sleep, and the daemon’s own log is the answer. One measured line, from the Handoff subsystem:
Grabbing power assertion to keep advertising until told to stop (client PID: …)
That is the mechanism, in Apple’s own words. When something on the Mac, or a nearby device, wants Handoff available, sharingd takes a power assertion, the same mechanism a video call or a running download takes, so the Mac will not doze off while it is meant to be discoverable. On the Mac measured here, pmset -g assertions showed no active sharingd assertion at the moment of sampling, because nothing needed one: the assertion is taken on demand and released when the advertising stops. If you are chasing a sleep problem, the assertion list will show it, and the client PID in the log line tells you which process asked sharingd to stay awake.
Why there are four of them in Activity Monitor
Open Activity Monitor, search for sharing, and on a Mac with Xcode installed you can see four or five rows. The breakdown:
- One
/usr/libexec/sharingd, the real one, running as your user since boot. There is exactly one. - Up to three more from iOS simulator runtimes, one per installed iOS version, each running inside its own simulator’s runtime root. They serve the simulator’s AirDrop and Handoff stories, not yours, and they come and go with the simulators. This Mac, with three runtimes installed, showed copies for iOS 27.0, 27.1 and 27.2.
- Possibly a row for
activitysharingd, which is a different daemon entirely: it belongs to ActivitySharingServices, the Apple Watch fitness sharing world, and shares nothing with this sharingd but five letters of its name.
The Activity Monitor answer, in one line: one real, the rest are simulators or a namesake.
The rest of the sharing family
The name family confused more than one reader, so here is the map. On a Mac, sharing with a small s is split across several daemons, and sharingd’s slice is discovery and features:
sharingdadvertises and negotiates. Finder, AirDrop, Handoff, hotspot discovery, share sheet.rapportdcarries the session once devices have met, and handles the features that need an ongoing pairing.- The SMB file server,
com.apple.smb.server, serves files. sharingd references its plist purely to know what to advertise in the Finder sidebar. - The screen sharing daemons serve screens.
com.apple.NetworkSharingruns internet sharing.cksharingmanagementdhandles CloudKit-based sharing of files and lists, andkeychainsharingmessagingdcarries iCloud Keychain messages, which is the feature whose alerts sit inside sharingd’s binary.
If a shared folder or a screen share ever breaks, the fault is almost never in sharingd. It was only ever the introduction.
If you kill it
You can, from a terminal: killall sharingd. Within a second, launchd starts it again, because KeepAlive is true and the plist says so. You will see the process ID change in Activity Monitor and nothing else happen, because nothing was wrong.
The reasons not to bother are in the measurements above. A minute and forty seconds of processor time a day. 27 MB of memory. One run since boot. Meanwhile the features it runs are the ones you would notice missing in an afternoon: AirDrop greyed out of the share sheet, no Handoff pickup, your hotspot absent from the Wi-Fi menu, the Finder’s shared sidebar empty. There is no setting called disable sharingd because there is no version of a Mac where you would want one. The settings that exist are the real ones: AirDrop discoverability, the Handoff switch, both in System Settings under General, AirDrop & Handoff.
The commands
Everything in this article came off one Mac, read only. The full set, verbatim:
ps -Awwo pid,ppid,user,%cpu,rss,etime,time,args | grep [s]haringd
man sharingd
ls -l /usr/share/man/man8/sharingd.8
plutil -p /System/Library/LaunchAgents/com.apple.sharingd.plist
launchctl print gui/$(id -u)/com.apple.sharingd
lsof -p $(pgrep -x sharingd) -i -P -n
strings -a /usr/libexec/sharingd | wc -l
strings -a /usr/libexec/sharingd | grep -i hotspot
pmset -g assertions
log show --last 30m --predicate 'process == "sharingd"' --style compact
The one thing the measurements cannot give you is the other end of the conversation. The log will happily tell you that one device was ranged a thousand times in half an hour and not tell you whose it is, because that is the design: your Mac knows its neighbours intimately, and keeps what it knows to itself.
Questions
What is sharingd on Mac?
It is the daemon that makes your Mac visible to other Apple devices and negotiates the first moments of every share. Its manual, unchanged since December 2012, describes the whole job in one line: it enables AirDrop, Handoff, Instant Hotspot, Shared Computers and Remote Disc in the Finder. When you AirDrop a photo, hand a draft from your iPhone to your Mac, or see your own hotspot listed before you ever opened Settings, sharingd did the introducing. It runs as your own user, not root, held about 27 MB of memory on the Mac measured here, and had spent roughly one minute forty seconds of processor time per day across twenty-six days of uptime.
Is sharingd a virus or malware?
No. It is Apple's own code, and you can check that yourself in five seconds: the binary lives at /usr/libexec/sharingd, and running codesign -dv on it reports the identifier com.apple.sharingd with a platform signature, the class of signing Apple reserves for the operating system's own files. It has run continuously since boot on a healthy Mac, with launchctl reporting one run and no exits. Malware occasionally imitates system process names, so the path column in Activity Monitor is the honest test: a real sharingd is always /usr/libexec/sharingd, and anything else with that name deserves a closer look.
Why does the firewall ask about sharingd accepting incoming connections?
Because the daemon binds network sockets that other devices connect to, which is exactly what the macOS application firewall exists to ask about. It is expected, not a sign of trouble. Denying it does not make you safer in any meaningful way, since the binary is Apple's own and platform signed; it just breaks incoming sharing until you allow it. On the Mac measured here sharingd held no TCP listener at all, only UDP sockets, including one bound to all interfaces and a web of IPv6 link-local conversations with nearby devices.
Why does sharingd want to use the login keychain?
Because the features it runs are built on keys and certificates, and it reads them constantly. Its logs show it calling SecItemCopyMatching, the keychain lookup, 122 times in half an hour on a Mac where nothing was being shared. It stores certificates it receives, it holds the hash store that powers AirDrop's Contacts Only mode, and its own binary carries a dedicated alert family for iCloud Keychain mismatches. If macOS shows you the prompt after a password change or a first unlock, it is the daemon reading its own items, and allowing it is the fix.
What is the difference between sharingd, rapportd and activitysharingd?
sharingd runs the features: AirDrop transfers, Handoff advertising and scanning, Instant Hotspot discovery, the share sheet, and the Finder's advertising of shared computers. rapportd runs Rapport, the session protocol that carries device-to-device work once contact has been made. The split is visible in sharingd's own log, which records receiving a Handoff request via Rapport, meaning sharingd spotted the neighbour and rapportd carried the conversation. And activitysharingd is unrelated to both: it is the Activity Sharing daemon from the Apple Watch fitness world, part of ActivitySharingServices, despite the confusing name.
Ready? Buy Ribbon for $15, or read all the guides.