HeartbeatHocusFocusFilesMacHyperTile
Guide

mDNSResponder: every name your Mac looks up goes through it

The process that answers every name your Mac looks up, and why macOS now asks whether an app may find devices on your local network.

By Chethan Kumar S N · Updated

Two searches bring people to this page, and they look unrelated. One is a name in Activity Monitor, sitting just under the CPU column, that you did not install and cannot remember seeing before. The other is a dialog box in the corner of the screen asking whether an app may find devices on your local network. They are the same story told from two ends, because the thing that does the looking is also the thing that does the asking.

Everything below comes from reading the process, its property list, its man page and its own log on a 14 inch MacBook Pro with an M1 Pro running macOS 27.0.1, plus Apple’s developer documentation for the permission side. Nothing was installed, no setting was changed, nothing was killed, and the only reason this page can quote the process’s inner workings is that macOS writes them down.

What the process is, in one command

One line is enough to place it:

$ ps -Awwo pid,ppid,user,%cpu,rss,etime,args | grep "[/]mDNSResponder"
  563     1 _mdnsresponder     0.0  11280 25-06:10:12 /usr/sbin/mDNSResponder
  575     1 root                0.0    800 25-06:10:11 /usr/sbin/mDNSResponderHelper

There are two of them, and the second one is the interesting part if you like knowing why your machine has more processes than you expected. Both have a parent process ID of 1, which means launchd started them at boot rather than any app launching them. The first runs as a user called _mdnsresponder, which is a real account on the system that is not yours. The second runs as root and is small: 800 KB of resident memory against the first process’s 11 MB.

The binary behind the first line is Apple’s, and you can check that without trusting anyone:

$ ls -l /usr/sbin/mDNSResponder
-rwxr-xr-x  1 root  wheel  5255808 Sep 24 12:40 /usr/sbin/mDNSResponder
$ lipo -archs /usr/sbin/mDNSResponder
x86_64 arm64e arm64e.x1
$ codesign -dv /usr/sbin/mDNSResponder
Identifier=com.apple.mDNSResponder
Authority=macOS Software Signing
Platform identifier=26
TeamIdentifier=not set

Five megabytes of executable, three architecture slices so the same file runs on an Intel Mac and on Apple silicon, signed by Apple’s own signing authority, and dated the same September day as the rest of the system. The helper is smaller, at 363,024 bytes, with the same three slices.

The account that exists only for it

_mdnsresponder is a service account, and the /etc/passwd style details are worth one command because they answer a question the Activity Monitor column raises:

$ dscl . -read /Users/_mdnsresponder UniqueID RealName NFSHomeDirectory UserShell
UniqueID: 65
RealName: mDNSResponder
NFSHomeDirectory: /var/empty
UserShell: /usr/bin/false

A user ID of 65 explains a search suggestion you have probably seen. Google’s autocomplete for the process name includes mdnsresponder (65), and that number is not part of the name: it is the user ID, and Activity Monitor’s User column renders this account as _mdnsresponder (65). People are searching the column they are looking at.

The rest of it is the shape of an account that can never be used. Its home directory is /var/empty, which is a folder that exists to be empty, and its shell is /usr/bin/false, which is a program that does nothing but exit with an error. Set a numeric user on a daemon and give that user no home and no shell, and you have a process that owns files and sockets without owning anything a person could log into.

The job it was launched with, read from its own property list

launchd reads a property list to know how to run it, and that file is the schedule made readable:

$ plutil -p /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist
{
  "Label" => "com.apple.mDNSResponder.reloaded"
  "UserName" => "_mdnsresponder"
  "GroupName" => "_mdnsresponder"
  "InitGroups" => false
  "EnablePressuredExit" => false
  "POSIXSpawnType" => "Interactive"
  "MachServices" => {
    "com.apple.dnssd.service" => true
    "com.apple.mDNSResponder.control" => true
    "com.apple.mDNSResponder.log_utility" => true
  }
  "Sockets" => { "Listeners" => { "SockFamily" => "Unix",
      "SockPathMode" => 438, "SockPathName" => "/var/run/mDNSResponder" } }
}

Three of those keys matter in practice. EnablePressuredExit set to false is the opposite of what the iCloud daemons declare: the system is not allowed to reclaim this process when memory runs short, so it stays up from boot to shutdown. MachServices registers the doors that other processes knock on, and the one named com.apple.dnssd.service is the DNS Service Discovery API, which is the door every app uses whether it knows it or not. Sockets creates a named Unix socket, and it is there on the disk with the permissions the plist asked for:

$ ls -l /var/run/mDNSResponder
srw-rw-rw-  1 root  daemon  0 Oct 20 12:56 /var/run/mDNSResponder

SockPathMode of 438 is that mode in decimal, which is 0666 in the octal people expect: readable and writable by every process on the machine, because every process on the machine is allowed to ask a question. The socket was created at boot on 20 October, which is the same day this Mac last started up, and it has been sitting there ever since.

Why there is a second, root process

Apple ships a man page for the helper, and it answers the question in its first line: mDNSResponderHelper is an executable invoked by launchd to provide privilege separation to the mDNSResponder daemon. Privilege separation means the part that needs root is split out and kept small, so the part that talks to the network does not run as root at all.

The strings inside the helper show what the privileged half actually does on this build:

set_ipv4_forwarding
set_ipv6_forwarding
net.inet.ip.forwarding
SetLocalAddressCacheEntry: socket(PF_ROUTE, SOCK_RAW, 0)

That is kernel work. Setting an interface’s forwarding flags and writing an entry into the kernel’s local address cache through a raw routing socket are both things an unprivileged process cannot do, and they are exactly the jobs you would not want bolted onto a daemon whose main occupation is answering questions from strangers on the network. The helper’s man page records that it first appeared in Mac OS X 10.5, so this division of labour has been in place since 2007.

It is not just Bonjour, it is the resolver for everything

The name makes people assume this process only matters for AirPlay and printers. The man page’s description line says otherwise in fourteen words: mDNSResponder is a daemon invoked at boot time to implement Multicast DNS and DNS Service Discovery, and on Mac OS X 10.6 it also became the system-wide Unicast DNS Resolver.

Unicast DNS is the ordinary internet kind. It is what happens when an app asks where a website lives, and on a Mac that question does not go from the app to your router directly. It goes to this process, which sends it, caches the answer, and returns it. The list of servers it sends to is not its own either: it is installed by configd, the daemon that sets the whole network up, and that daemon has its own page. The bridge runs in the other direction too: netbiosd, the registrar for the 1987 NetBIOS naming protocol, hands every name it scavenges off an old workgroup network to this process, and that daemon has its own page. The process is also the one place where every such request can be counted, which is why the next section exists.

One hour of its log, counted

macOS keeps a searchable record of what a process does, and it does not need administrator rights to read:

$ log show --last 60m --predicate 'process == "mDNSResponder"' --style compact | wc -l
   34031

Thirty four thousand lines in one hour, from 18:07 to 19:07. The lines are not all the same kind of event, and grouping them is where the picture appears:

What the log countsIn one hourWhat it means
getaddrinfo, started265lookups requested by apps
getaddrinfo, returned2,209answers handed back to the askers
Question assigned to a DNS service6,487individual name questions put to a resolver
A type questions5,720IPv4 addresses
AAAA type questions5,217IPv6 addresses
CNAME type questions946alias chains
HTTPS type questions163the modern record that carries connection hints
TXT type questions110service metadata, mostly Bonjour
PTR type questions39reverse lookups, which is how service discovery works

The AAAA count nearly matching the A count is the honest explanation for why a Mac with IPv6 looks like it asks twice as many questions as an old one. macOS asks for both families in parallel and uses whichever answers first.

Then there is the column that makes this log worth reading at all. Every lookup names the process that asked for it:

getaddrinfo start -- flags: 0xC000D000, ifindex: 0, hostname: <private> <dn:9r3HFw>,
  options: 0x8 {use-failover}, client pid: 1630 (MSTeams)

The hostname is masked as <private>, because Apple treats the name you looked up as personal data. The client is not masked. In that same hour the log named 156 distinct process and name pairs, from 61 different processes, and ranking them by how much they asked is a portrait of a busy machine:

ClientLog lines in the hour
node1,328
Comet Helper708
Codex (Service)206
CopperRiver162
Chromium Helper162
curl120
OpenUsage82
Slack Helper80
Microsoft Teams62
Claude Helper58
Microsoft Outlook56

Three developers’ tools at the top, two browsers, a chat client, a mail client and a terminal command. Nothing Apple’s own sits in the top ten on this Mac, and that is the correction the name invites: this is not a process that Apple’s services use, it is a process that everything uses, and Apple’s services happen to be a small part of the traffic.

The watching runs both ways, and the proof is on the other side of the fence. The daemon that scores the Mac’s network health keeps a per-flow record of its own, and mDNSResponder is the second most-watched process on this Mac in its log, 151 lines in a single day, every one a UDP flow being opened or rebounded. Each DNS lookup is a network flow too. The symptomsd page shows what that record looks like from the inside, process names, bundle identifiers and all.

It is also cheap. Process time for the daemon on this Mac is 39 minutes 29 seconds against 25 days of uptime, which averages out at about a tenth of one per cent of one core, and the memory reading is 11 MB with a momentary 0.0 per cent CPU in the top sample taken for this page.

The socket on 5353, and the live version of the other half

The man page gives the transport: mDNSResponder listens on UDP port 5353 for Multicast DNS Query packets, and when it receives a query it knows the answer to, it issues the reply. That port is how devices on the same network find each other without a server, and the process is the only thing on a Mac that speaks it on the system’s behalf.

You can watch it work with a command Apple ships for the purpose. dns-sd asks the same API every Bonjour app uses, and browsing for the master list of service types for seven seconds on this Mac returned:

$ dns-sd -B _services._dns-sd._udp
19:09:39.442  Add  3  14 .  _tcp.local.  _airplay
19:09:39.442  Add  3  14 .  _tcp.local.  _raop
19:09:39.442  Add  3  14 .  _tcp.local.  _companion-link
19:09:39.442  Add  3  14 .  _udp.local.  _asquic
19:09:39.442  Add  2  14 .  _tcp.local.  _googlecast

Five types, all of them things a person would recognise once translated. _airplay is screen and media streaming, _raop is the audio-only variant Apple’s own speakers advertise, _companion-link is the Continuity link between your Mac and your iPhone, _asquic belongs to Apple’s Quick Reliable Transport, and _googlecast is Chromecast discovery from a browser. The last one is a neat detail all on its own: a Mac is not a Chromecast device, but a browser installed on it can still ask the network who is, and the machinery is the same one AirPlay uses. And the daemon on the Mac side of that _companion-link advertisement is rapportd, which its own page reads through its three launch jobs, its listening socket and the pairing vocabulary inside its binary.

The other side of that traffic shows up in the log as registration records, with the durations attached. Over the same hour, one daemon registered and released a record repeatedly, in each case naming itself as the client:

DNSServiceRegisterRecord START -- name: <private>, client pid: 453 (apsd), name hash: <dn:gkXDRw>
DNSServiceRegisterRecord STOP  -- name: <private>, client: apsd(pid: 453), duration: 5m 49s

Nothing here is hidden out of mystery: the record names are the same <private> markers, which is why a log like this can answer “which app is doing this” but cannot answer “which printer”.

The prompt that brings the other half of the traffic here

If you arrived because your Mac asked whether an app may find devices on your local network, the answer starts with a feature introduced in macOS 15. Apple documents it for developers in TN3179, Understanding local network privacy, and describes it in one sentence worth quoting whole: local network privacy puts people in control of which programs can interact with devices on their network.

The mechanism is simple. A program starts in an undetermined state. The first time it performs a local network operation, macOS shows the alert, you choose, and the choice is recorded and applied from then on. Apple’s technote then gets specific about what counts, and the table is more interesting than the summary:

OperationNeeds permission
Making an outgoing TCP connection to a local addressyes
Listening for and accepting incoming TCP connectionsno
Sending a UDP unicast, multicast or broadcastyes
Receiving an incoming UDP unicastno
Receiving an incoming UDP multicast or broadcastyes
Resolving a name that ends in .localyes
Resolving an internet name through the system resolverno

Two lines in that table explain most of the confusion around this feature. Listening for connections does not need permission, so a file sharing service can sit there with its port open without ever prompting. And a normal web lookup does not need permission either, which is why your browser can load the entire internet without a word, then ask for one specific permission the first time a page tries to discover a device on your own network. Apple’s definition of the local network is the honest one: an IP network attached to a broadcast capable interface, Wi-Fi and Ethernet but not cellular or VPN, and multicast addresses and the IPv4 broadcast address are local by definition regardless of where they are.

Bonjour gets its own section in the technote, and it is three lines long. Registering a service with Bonjour, browsing for Bonjour services, and resolving a Bonjour service all require local network access. That is the link between the two halves of this page: the dialog you clicked is what lets an app do, for its own purposes, the thing mDNSResponder does on your behalf for Apple’s.

Why Terminal never asks and that app did

The most useful part of the technote for anyone who has never written an app is this list. On macOS, local network access is granted automatically to any daemon started by launchd, any program running as root, and command line tools run from Terminal or over SSH, including the processes they spawn.

That explains the odd pattern people notice. A developer’s own command line tool reaches the network without a prompt, because Terminal and the shell under it are trusted, while the same code inside a downloaded app triggers the dialog the first time. It also explains why a file sharing daemon can advertise itself without asking you: it is a launchd daemon. Apple adds the important exception in a note, that this does not apply to launchd agents, only daemons, which is the difference between something the whole system owns and something a user session starts.

Two more details from the same page are worth keeping. macOS keeps local network privacy state per user account, so a second user on the same Mac gets their own list and their own prompts. And the technote is candid about a known gap: macOS will not show the alert at all if the process that reaches the network is very short lived, which is how you can end up with a program that plainly used the network and no record of being asked.

Where the switch is, in the pane’s own words

The list lives in System Settings under Privacy & Security, and like the login items pane, it is a real app on disk whose own strings tell you what it will say before you open it:

$ plutil -convert json -o - /System/Library/ExtensionKit/Extensions/SecurityPrivacyExtension.appex/Contents/Resources/Localizable.loctable
"LOCAL_NETWORK" = "Local Network"
"LOCAL_NETWORK_SUMMARY" = "Allow the applications below to find and communicate with devices on your local network."
"LOCAL_NETWORK_EMPTY_APP_LIST" = "Applications that have requested permission to find and communicate with devices on your local network will appear here."

That empty list state is the one worth knowing, because it is what a Mac that has never been asked will show, and it reads as a page with nothing on it rather than as a setting that has not been used yet.

The same pane’s service registry file puts local network in context. It is one entry in the list of privacy services the pane renders, as its own class rather than part of anything else:

6 => { "serviceClass" => "PrivacyLocalNetworkService" }

Compare its neighbours. The Bluetooth entry a few lines above carries "requiresAdmin" => true and "supportsAddDeleteAction" => true, meaning an app can be removed from that list by hand. The local network entry carries neither, and Apple says why in the technote: the add and remove buttons in that list were introduced in macOS 27.2, and before that release there was no way to reset a program’s local network privilege at all, a limitation Apple tracks as FB14944392. This Mac runs 27.0.1, which is why the file declares no delete support.

Apple’s user facing article on the same subject is written for iPhone rather than Mac, and the technote says so directly when it links to it. If you search for this on a Mac and find only iOS instructions for resetting a permission, that is not your mistake. On macOS the answer is the pane itself, until 27.2 arrives with buttons for it.

What to do about it

For the dialog: answer it once, honestly, and expect not to see it again for that app. Allowing it lets the app look for devices on your network, which is what a media app, an IoT app or a browser casting to a TV needs. Denying it does not crash anything. The app simply cannot see your network, so its local discovery feature stops working, and clicking Deny is a complete answer rather than a warning you have to live with.

For the list in Settings: the only thing worth removing is an app you no longer use, and on macOS 27.2 and later you do that with the remove button Apple added. Removing it returns that app to undetermined, so it will ask again the next time it tries, which is the point of a reset rather than a permanent ban.

For the process itself: nothing. It is not using your battery or your processor in any way that matters, and the numbers on this page were taken to make that concrete rather than reassuring. If it does spike, the question is which app asked, and the log line quoted above answers it in one command.

And for the advice you will find elsewhere: applications that promise to clean up or speed up your Mac’s network have nothing to do here. There is no cache to empty in a way that helps, and no setting to tune. The old tool for reading the resolver cache, dscacheutil -statistics, has nothing to report on this build either, which is a reasonable sign that the plumbing is not meant to be managed by hand any more.

What this page cannot tell you

Apple never names this process in the user documentation. Searching the technote for the process name returns nothing, and neither does the Mac user guide page that covers privacy controls. The behaviour is documented thoroughly and the machinery is not, which is the reverse of what most people expect and the reason the man page matters so much here. The man page, TN3179 and the strings files above are the sources, and the measurements are from one machine, one build and one hour.

The second limit is the redaction, which cuts both ways. The log is unusually good at telling you which app asked and unusually bad at telling you what it asked for, because names, record data and addresses are all replaced with <private> markers. Counting is precise, identifying is not.

And the third is that Apple’s own documentation changes. The technote lists two hidden preferences for exempting entire networks from these checks, which only an administrator would set, and the add and remove buttons in the pane arrived in a point release. Any page about a moving target is only as good as the build it was written on, which here is 27.0.1.

Where window managers fit

Nothing on this page touches how your windows behave, and no amount of network hygiene makes a desktop easier to work on. The two meet at the same feeling, though: a Mac that seems to be doing a great deal you did not ask for. Background items, resolving names, syncing photos and indexing files are the invisible half of that, and windows are the visible half, which usually means a screen full of overlapping windows and Control Up used as an expedition.

Ribbon takes the other approach. Windows stay at full size on a single scrolling strip instead of stacking, 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

mDNSResponder is the daemon every name lookup on your Mac passes through, both the multicast kind that lets devices find each other and the ordinary internet kind, which it has handled system wide since Snow Leopard. On this Mac it runs as a dedicated account, _mdnsresponder, with user ID 65, no home folder and no shell, alongside a small root helper whose whole job is the handful of operations that need kernel privileges.

You can measure it rather than guess. One command over one hour returned 34,031 log lines, 265 lookups, 6,487 name questions and 156 distinct asking processes, and it used about 39 minutes of processor time in 25 days of uptime. Every lookup in that log names the app that asked, while masking the name it asked for.

The dialog about finding devices on your local network is the same subject from the other direction. Since macOS 15, reaching a device on your own network needs permission, Bonjour operations are included, and the permission is per app and per user account. Launchd daemons, root programs and command line tools are trusted automatically, which is why a developer’s tool never asks and a downloaded app does.

The only action worth taking is at the dialog, and it is a decision rather than a cleanup: allow it if you want the app to see your network, deny it if you do not, and ignore the process itself either way. It is not the problem, and it is not going anywhere.

Questions

What is mDNSResponder on Mac?

It is the daemon that does your Mac's domain name work. Apple's own man page describes it in one line as the Multicast and Unicast DNS daemon, and adds that since Snow Leopard it has also been the system-wide Unicast DNS Resolver. In plain terms, when any app asks where a name points, that question is handed to this one process, which sends the query, keeps a cache of the replies, and speaks the separate multicast protocol that makes AirPlay, printers and Continuity find each other on your network. On this Mac it is a single process, PID 563, running as a dedicated account called _mdnsresponder, and it had used about 39 minutes of processor time in 25 days of uptime.

Is mDNSResponder a virus or malware?

No. It is Apple's own code, it lives in /usr/sbin, and it is signed by macOS Software Signing, which is the authority Apple's own system binaries carry. The home folder for its user account is /var/empty and its login shell is /usr/bin/false, which is how macOS sets up an account that exists to own a process and can never be logged into. The reason it shows up without warning is that it appears in Activity Monitor with a name unlike anything you installed, and users search it before reading the process path.

Why is my Mac asking whether an app can find devices on my local network?

Because since macOS 15, reaching a device on your own network needs permission, the same way the camera or microphone does. Apple's technote on the feature, TN3179, states it as a single sentence: local network privacy puts people in control of which programs can interact with devices on their network. The first time a program performs one of those operations the alert appears, and the answer is remembered for that app. Bonjour browsing and resolving, sending something to a local address, and any lookup of a name ending in .local all count. A normal lookup of an internet name through the system resolver does not.

Can I disable or stop mDNSResponder?

You can, and there is no reason to. Apple's man page is blunt about it, saying the daemon has no user-specifiable command-line argument and that users should not run it manually. Force quitting it works the same way force quitting any launchd job does, which is that the process goes away for a moment and comes straight back, and the job that restarts it on this Mac has EnablePressuredExit set to false, so the system is not allowed to quietly reclaim it the way it reclaims the iCloud daemons. Nothing good happens in between: names stop resolving for as long as it is gone.

Why is mDNSResponder using high CPU or network, and how do I see who asked?

Because it is doing work for something else. The process you should look at is the client, not the responder, and macOS will tell you which app asked if you read its log with the mDNSResponder process filter for the last fifteen minutes in Terminal: each getaddrinfo line ends with the asking process, for example client pid: 1630 (MSTeams). In one hour on this Mac that log recorded 265 lookups from 156 different process and name pairs, so a busy responder usually means an app or a service is retrying something.

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