# nsurlsessiond, the daemon that finishes your downloads

> nsurlsessiond finishes the downloads you did not wait for. What it is, the folder that names every app that used it, and what to switch off.

Source: https://www.ribbonmac.com/guides/nsurlsessiond-mac · Updated 2026-11-17

nsurlsessiond is the process people find after they go looking for something else. You open Activity Monitor to find out why a Mac is warm or why the Wi-Fi is busy, spot a name with no vowels in useful places, and search for it. The two answers you find are that it is malware, and that you should disable it. Both are wrong, and the second one is wrong in a way that leaves you with more questions than you started with.

Here is why the name exists. NSURLSession is Apple's programming interface for network transfers. The letter d on the end is the usual Unix convention for a daemon, a process that runs in the background rather than in a window. So the whole name means the background service for Apple's network transfer interface. Nothing about it refers to a file of yours, and nothing about it is hidden.

Everything below comes from three places: Apple's own documentation, the files the daemon and its clients ship on disk, 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 network setting was changed, and no transfer was cancelled.

## What nsurlsessiond actually is

One command gives you its identity, and on this Mac it returns two lines rather than one:

```text
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,args | grep "[/]usr/libexec/nsurlsessiond"
  967     1 _nsurlsessiond     0.0   5520    02:39:09 /usr/libexec/nsurlsessiond --privileged
 1039     1 chethankumar       0.0   4944 25-01:11:01 /usr/libexec/nsurlsessiond
```

Read the first line first, because it is the one that explains the second. Both processes have PID 1 as their parent, which is launchd, so the system started them and not an app. But they run as different users. The privileged copy runs as an account called `_nsurlsessiond`, and the other runs as you.

That account is worth a look, because Apple is unusually frank about what it is for:

```text
$ dscl . -read /Users/_nsurlsessiond
GeneratedUID: FFFFEEEE-DDDD-CCCC-BBBB-AAAA000000F2
NFSHomeDirectory: /var/db/nsurlsessiond
Password: *
PrimaryGroupID: 242
RealName: NSURLSession Daemon
UniqueID: 242
UserShell: /usr/bin/false
```

The real name of the account is literally NSURLSession Daemon. Its home directory is `/var/db/nsurlsessiond`, which on this Mac was empty, and its shell is `/usr/bin/false`, which is the standard way of creating an account that can own files and processes but cannot be logged into. There is no password on it either, and the asterisk in that field is how Apple records a disabled password. This is a working account rather than a person.

The elapsed time column is the other half of the story. The copy running as you had been up for 25 days and a bit, which matches the uptime, so it has been alive since boot. The privileged copy had been up for two hours and 39 minutes, which means it was started again during this session rather than at boot. That is what an on demand service looks like: the privileged one runs when a system level transfer needs it and is stopped when the machine is idle, and the one running as you stays resident because anything you launch might want it.

Then look at what it costs. Neither process had used any measurable CPU at the moment of the check, and the totals across the whole uptime are small enough to be worth stating plainly:

```text
$ ps -o pid,time,%cpu,rss,args -p 1039 -p 967
  PID      TIME  %CPU    RSS ARGS
 1039   5:16.04   0.0   4944 /usr/libexec/nsurlsessiond
  967   0:00.62   0.0   5568 /usr/libexec/nsurlsessiond --privileged
```

Five minutes and 16 seconds of processor time over 25 days of uptime works out at about one hundredth of one percent of a single core. The memory figure is about five megabytes, which is smaller than a single browser tab. A process that behaves like this is not the reason a Mac feels slow. When people see nsurlsessiond at the top of a CPU list it is because they caught it mid transfer, and the sorting did the rest.

## The binary, for anyone who wants the receipts

The executable is Apple's, and every check that matters can be run without special access:

```text
$ ls -l /usr/libexec/nsurlsessiond
-rwxr-xr-x  1 root  wheel  1583728 Sep 24 12:40 /usr/libexec/nsurlsessiond

$ lipo -archs /usr/libexec/nsurlsessiond
arm64e arm64e.x1

$ codesign -dv /usr/libexec/nsurlsessiond
Identifier=com.apple.nsurlsessiond
Format=Mach-O universal (arm64e arm64e.x1)
Platform identifier=26
Signed Time=9 Aug 2026 at 6:29:56 AM
Info.plist entries=21
TeamIdentifier=not set
```

It is a 1.5 megabyte Mach-O binary owned by root and the wheel group, and on this ARM build it carries two arm64e slices and no Intel slice, which is what the platform binaries in macOS 27 look like on Apple silicon. The identifier is `com.apple.nsurlsessiond`, the platform identifier of 26 marks it as a system provided binary rather than a third party app, and TeamIdentifier being unset is normal for Apple's own code, which is signed by a different mechanism than a developer's app.

The entitlements are the part that tells you what it is trusted to do:

```text
$ codesign -d --entitlements - /usr/libexec/nsurlsessiond
```

Twenty four keys come back. Three are worth naming.

`com.apple.networkd.configure_connection_pool` and `com.apple.networkd.join_connection_pool` let it own and share network connections system wide, which is exactly what a download service needs in order to multiplex many transfers over few connections. `com.apple.duet.activityscheduler.allow` lets it register work with the scheduler that decides when background jobs run, and that entitlement is the mechanical explanation for everything in the section about timing below. And when those pooled connections speak HTTPS, the certificate check on each one is not done here at all: it is handed to [trustd, the certificate trust daemon](https://www.ribbonmac.com/guides/trustd-mac), which runs 25,000 such checks in 45 minutes on a quiet Mac.

The binary also carries the names of the private entitlements it is allowed to hand out to the apps that connect to it, and those names are a small dictionary of the concepts involved. `com.apple.private.nsurlsession.allow-discretionary-cellular` is permission to run a background transfer over a phone network. `com.apple.private.nsurlsession.set-discretionary-override-value` is permission to override the scheduling decision. `com.apple.private.nsurlsession.impersonate` is permission to act as another app. `com.apple.private.nsurlsession.set-max-watch-cell-transfer-size` is permission to cap a transfer made from a watch. None of these are user facing, and the point of listing them is that the daemon's whole vocabulary is about deciding when a transfer may run and who it may run as.

## There is no timer in this job

Every LaunchAgent on macOS has a file describing when it runs, and this one is short enough to read in full:

```text
$ plutil -p /System/Library/LaunchAgents/com.apple.nsurlsessiond.plist
{
  "EnablePressuredExit" => true
  "EnableTransactions" => true
  "Label" => "com.apple.nsurlsessiond"
  "MachServices" => {
    "com.apple.nsurlsessiond" => true
    "com.apple.nsurlsessiond-launchondemand" => true
  }
  "POSIXSpawnType" => "Adaptive"
  "Program" => "/usr/libexec/nsurlsessiond"
  "QueueDirectories" => [
    0 => "~/Library/com.apple.nsurlsessiond"
  ]
}
```

Compare that with the plists behind the other daemons people search for. The Photos analysis jobs carry ten named tasks with repeating intervals of two, six, eight and twenty four hours. This file has no interval at all. There is no `StartInterval`, no `StartCalendarInterval` and no `RunAtLoad`, which means nothing in it says run at this time or run at boot.

What it says instead is run when someone asks. `MachServices` registers two doors that any process on the system can knock on, and `QueueDirectories` names a folder that launchd watches, so that writing a file into it is itself a request. `POSIXSpawnType` of Adaptive tells launchd to tune the process for lower resource use, and `EnablePressuredExit` marks it as expendable: the system is allowed to reclaim it under memory pressure rather than letting it hold pages nobody is using.

The live record agrees:

```text
$ launchctl print gui/501/com.apple.nsurlsessiond
	type = LaunchAgent
	state = running
	minimum runtime = 10
	exit timeout = 5
	runs = 1
	pid = 1039
	immediate reason = ipc (mach)
	last exit code = (never exited)
	event triggers = {
		com.apple.launchd.QueueDirectories => { ... }
	}
```

Two lines there tell the whole story. The immediate reason is ipc (mach), which means another process asked for it over one of those mach service doors rather than a clock starting it. And `last exit code` reads never exited, because it has not been restarted since boot: it was started once by the first thing that needed a background transfer and has been in memory since. The queue directory itself, `~/Library/com.apple.nsurlsessiond`, did not exist on this Mac at the time of the check, which is the honest state of a system where nothing had recently asked for that particular route.

So the answer to can I stop it is the answer nobody wants. Quitting it is easy and temporary. There is no schedule to disable, because it has none.

## The folder that names every app that has used it

This is the part worth the whole page. macOS keeps a directory of background sessions, and inside it there is one subfolder per app that has ever opened one, named after the app's bundle identifier:

```text
$ ls ~/Library/Caches/com.apple.nsurlsessiond/Downloads
Google Chrome for Testing
ai.perplexity.comet
com.apple.amsaccountsd
com.apple.amsengagementd
com.apple.bird
com.apple.cloudd
com.apple.gamed
com.apple.geoanalyticsd
com.apple.parsecd
com.openai.codex
```

Ten folders, and every one of them is a straight answer to a question people ask in forums. `com.apple.bird` is the iCloud Drive daemon. `com.apple.cloudd` is iCloud itself, [and the cloudd page follows what happens to those transfers on the other side](https://www.ribbonmac.com/guides/cloudd-mac). `com.apple.amsaccountsd` is the App Store's own account agent, a near-twin of [the accounts daemon](https://www.ribbonmac.com/guides/accountsd-mac) that calls it 58 times a day. `com.apple.geoanalyticsd` handles Maps and location data. `com.apple.gamed` is Game Center, and `com.apple.parsecd` is part of the media parsing stack. The last four are not Apple's at all: a Chrome for Testing build, Perplexity's Comet browser, and OpenAI's Codex command line tool.

That mix is the single most useful fact on this page, because it settles an argument. If nsurlsessiond were a system service doing Apple's own housekeeping, nothing third party would have an entry. The presence of a browser and a command line tool proves the daemon is a general purpose courier that any app can hire.

One absence is worth explaining, because it is the question that brings a lot of people here. Photos is not in that list by name, and yet Apple's own file for the photo sync engine names this daemon as one of the processes involved when a library is first downloaded from iCloud. The work is there, under the name of the service that asked for it, [which the cloudphotod page follows from the other end](https://www.ribbonmac.com/guides/cloudphotod-mac).

The dates on the folders are a log of when each app last needed it:

| Folder | Last used |
| --- | --- |
| com.apple.geoanalyticsd | 14 November 2026, 06:00 |
| com.apple.bird | 13 November 2026, 09:59 |
| com.apple.amsaccountsd | 9 November 2026, 10:12 |
| com.apple.amsengagementd | 20 October 2026, 13:00 |
| Google Chrome for Testing | 28 September 2026, 10:38 |
| com.openai.codex | 19 September 2026, 22:16 |
| com.apple.gamed | 19 September 2026, 21:40 |
| ai.perplexity.comet | 19 September 2026, 20:57 |
| com.apple.parsecd | 19 September 2026, 20:51 |
| com.apple.cloudd | 19 September 2026, 20:47 |

Only three of the ten had been touched in the fortnight before this was written, and the newest was that morning. Six of them dated from the day the Mac was first set up, which is exactly what you would expect: setting up a new machine means downloading a great deal of Apple's software in the background, and every one of those sessions left a folder behind.

Inside the folders there was nothing at all. Zero files across all ten. That is by design rather than an accident: the partial file lives in the folder while the transfer is running, and it is moved into place or deleted once the transfer finishes or fails. So an empty folder is not evidence of a broken download. It is evidence of a finished one, and the date on the folder is when that happened.

## Why it waits, and why it picks the worst time

The reason a download you started at lunchtime finishes at three in the morning is a concept called discretionary transfer, and Apple documents it in a paragraph that is worth quoting rather than paraphrasing. From the developer documentation for the `isDiscretionary` setting on a background session:

> When transferring large amounts of data, you are encouraged to set the value of this property to true. Doing so lets the system schedule those transfers at times that are more optimal for the device. For example, the system might delay transferring large files until the device is plugged in and connected to the network via Wi-Fi.

And then the sentence that explains every surprising timestamp:

> The session object applies the value of this property only to transfers that your app starts while it is in the foreground. For transfers started while your app is in the background, the system always starts transfers at its discretion, in other words the system assumes this property is true and ignores any value you specified.

Read that twice, because it is the load bearing fact. An app can ask for a transfer to run immediately, and the request is honoured only if the app is on screen at the time. The moment the app goes to the background, the decision belongs to macOS.

The strings inside the binary show the same idea from the other side, in the daemon's own working vocabulary:

```text
Application %@ has been in background for %lu seconds. Will reevaluate discretionary downloads
%@ client is in transistional discretionary period - updating activity _DASActivity %@
NDSession <%@> current discretionary status for %@ is non-discretionary, since nsurlsessiond is running in EDU sync mode
NDSession <%@> setting discretionaryOverrride to %c, QOS(0x%x)
```

The third one is a curiosity rather than a threat: EDU sync mode is the configuration Apple uses in education deployments that have their own caching server. The others describe the ordinary case. An app that drops out of the foreground starts a clock, and when its status is re-evaluated the transfer may be demoted to discretionary and pushed to a later, cheaper moment.

The `_DASActivity` at the end of the second line is the same duet activity scheduler that decides when Photo analysis runs, and the binary holds the entitlement to talk to it. That is the loop, stated completely: the app asks, the daemon accepts, the daemon registers the work with a scheduler, and the scheduler runs it when the machine is on power and quiet.

None of this is a malfunction, and it has one practical consequence worth knowing. If a large download seems stuck, the fix is usually not to restart anything. Plug the laptop in, stay on Wi-Fi, and leave the lid open. You have told the system exactly what it was waiting for.

## Cellular, expensive and constrained

The scheduling decision is not only about time. Every background session also declares which kinds of network it is willing to use, and the terminology is in the log lines:

```text
Session <%@> is for <%@>.<%@> using resource timeout: %f, request timeout: %f
  allowsCellularAccess: %d, allowsExpensiveAccess: %d, allowsConstrainedAccess: %d
```

Three separate permissions, and they are not the same thing. Cellular access is about using a phone network at all. Expensive access is about metered connections, which on a Mac is usually a tethered phone rather than home broadband. Constrained access is about networks that are slow or marked as being in a low data mode, which covers both a Low Power Mode style hint and a genuinely poor link.

Higher up the same list there is a fourth, and it is the one that answers the most common complaint about a laptop that downloaded a great deal on a train:

```text
Client tried to set _maximumWatchCellularTransferSize but is missing the necessary entitlement
NDSession <%@> attempted to set discretionaryOverrride to %c but lacks required entitlement %@
```

The daemon refuses to let an ordinary app declare itself above the rules. A client that tries to force a transfer past the scheduling decision, or to raise the cellular cap, is told no unless it holds one of those private entitlements, and private entitlements are Apple's to hand out. The rules are the system's, not the app's, and the log records every attempt to break them.

## What to switch off, and what it costs you

There is no switch labelled nsurlsessiond, and that is the honest answer rather than a dodge. What exists is a set of switches over the work that generates the traffic, and they are spread across two apps. The names below are the names the apps themselves use, read from their own string files rather than recalled.

| Where | Setting | What it actually does |
| --- | --- | --- |
| App Store, Settings | Automatic Updates | The subtitle in the app says it: App Store will download and install app updates automatically |
| App Store, Settings | Automatically download apps purchased on other devices | Pulls apps and media bought on your phone or iPad without you asking |
| App Store, Settings, In-App Content | Automatically download in-app content | Its subtitle is unusually direct: Automatically run apps in the background to download content before you first launch them |
| System Settings, General, Software Update | Download new updates when available | Fetches macOS updates ahead of time, behind the small i button next to Automatic Updates |
| System Settings, General, Software Update | Install macOS updates | Takes it further, with the warning that your Mac will try to update later tonight and will automatically restart |

The third row deserves attention, because it is the one most people have never read. When it is on, macOS is permitted to run an app in the background, before you have ever opened it, purely so that its content is already there when you do. That is a real behaviour with a real cost, and knowing the sentence exists is what makes the setting a choice rather than a mystery.

Two more levers are less obvious and often more effective. Low Power Mode reduces what the system is willing to do in the background, which is the closest thing to a global throttle. And the folder list itself is a list of suspects: if the traffic is coming from a bracket you installed and no longer use, quitting that app removes its sessions, and leaving it uninstalled removes its folder on the next cleanup.

There is a local receipt for how much of this is going on. Two preference domains on this Mac had recorded their own recent activity:

```text
$ defaults read com.apple.appstored | grep LastAutoUpdateCompletion
    LastAutoUpdateCompletion = "2026-11-12 13:57:45 +0000";

$ defaults read com.apple.SoftwareUpdate
    AvailableUpdatesNotificationCountKey = 3;
    AvailableUpdatesNotificationProductKey = "MSU_UPDATE_26A434_patch_27.0.1_minor";
    UserNotificationDate = "2026-11-12 23:02:48 +0000";
```

The App Store finished an automatic update at 13:57 on 12 November, and the software update machinery logged a notification about the 27.0.1 patch at 23:02 that night. Every byte of both of those moved through nsurlsessiond. If you are trying to work out where a quiet Mac's network activity went, those two domains are a better place to look than Activity Monitor, because they record what happened after the process has already exited.

## Who sees the bytes

The daemon is a courier, and the useful question is not what it knows but what it exposes. Apple's App Store privacy page answers one part of that precisely, and it is the part that surprises people:

> In addition, when automatic downloads of in-app content from app developers occur, your device's IP address will be visible to the app developer before the app is first opened.

That is the same feature whose settings subtitle says it will run apps in the background to download content before you first launch them. Apple is stating, in its own privacy documentation, that turning it on means a developer can see your address at a moment when you are not using their app. The same page notes that for a normal download identifiers such as your device's hardware ID and IP address are logged by Apple along with your account, and that receipts given to developers do not include personal data, though a developer could tie them to data you gave them elsewhere.

The mirror image is also on that page, and it is fair to include it: Apple states that its recommendation processing happens on your device, and that information about which apps are installed is retrieved privately to improve recommendations. The privacy model here is not one thing. Some of it stays local, some of it reaches Apple, and the transfer machinery underneath is the same in all three cases.

What the courier itself holds is the least interesting part and the easiest to state. Its database schema names its own tables, `sessions` and `session_tasks`, and the columns are the metadata of a transfer: the session identifier, the bundle identifier of the client, the current request, a byte per second limit, the loading priority, and the discretionary flag. There is no column for content. The bytes are on their way through, and what remains afterwards is the note that they went.

## Can you quit it, or turn it off?

You can quit it in Activity Monitor and it will come back, and the return is instant rather than scheduled, because the door it listens on is open the whole time. Force quitting it in the middle of a transfer does not cancel the transfer either. The session state is on disk, the task list is on disk, and the provisional file is on disk, so the same download resumes when the daemon restarts and the machine is next in the right conditions. What you have achieved is a pause with extra steps.

There is no supported way to keep it from running, and there is a good argument for not trying. This is the process that lets a 40 gigabyte Xcode download survive a closed lid, that lets an app you have quit finish updating itself, and that keeps a file sync from stalling because you closed a window. Removing it would break downloads in ways that are painful to diagnose, because the failure would look like an app that simply cannot fetch things.

## One thing worth knowing about storage

Because partial downloads live on disk while they run, they have a size, and macOS eventually stops being polite about them. Apple's own page on optimising storage lists what the system clears when space is needed, and the list is worth reading closely:

> When space is needed on your Mac, macOS also clears caches and logs that are safe to delete, including temporary database files, interrupted downloads, staged macOS and app updates, Safari website data and more.

Interrupted downloads and staged updates are two of the daemon's products. So if a stalled transfer seems to have vanished rather than completed, it may have been cleaned up rather than lost, and the honest next step is to start it again rather than to hunt for it.

## What this page cannot tell you

Apple never names the process in its user documentation. The term does not appear anywhere in the macOS user guide index, and it does not appear in any of the individual pages consulted for this article, which cover iCloud Drive, storage optimisation, downloading apps, and what iCloud is. Everything above about the name, the schedule and the folder came from the operating system's own files rather than from a support article about it. The same is true of its counterpart on the name side of the network, [mDNSResponder](https://www.ribbonmac.com/guides/mdnsresponder-mac), which Apple describes in a man page and not in the user guide, even though every lookup on the machine goes through it.

There is also no published figure for what counts as normal. Apple documents the mechanism and the intent, not a bandwidth budget, so a page claiming that nsurlsessiond should use under a certain number of megabytes an hour is inventing the number. The honest way to judge it is relative: look at the ten folders, look at the dates, and decide whether the apps that appear there have any business downloading what they are downloading.

And the folder list is a bookmark rather than a log. It tells you an app opened a background session and roughly when. It does not tell you what was transferred, how much of it there was, or where it came from, and no supported tool exposes those either. If you need that level of detail, the transfer you are looking for is better traced from the app that asked for it.

## Where window managers fit

Nothing here is a window problem, and this page is not going to pretend otherwise. If a Mac feels slow, nsurlsessiond is a plausible explanation for a minute or two during a large transfer, and one hundredth of a percent of a core across 25 days of uptime is not an explanation for anything.

The other half of that feeling is what is on the screen, and that half you can fix in a minute rather than in a settings pane. Nineteen overlapping windows, a Dock full of things you cannot identify, and Control Up used as a search expedition will make a fast machine feel slow no matter what the background jobs are doing.

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](https://www.ribbonmac.com/#drive) before installing anything.

## The short version

nsurlsessiond is the background download service, it lives in `/usr/libexec`, it is signed by Apple, and it also runs a second copy under a system account whose only declared purpose is to be the NSURL Session Daemon and whose shell is `/usr/bin/false`.

It has no timer. It is started over a mach service or by a file appearing in a queue directory, it held one start since boot on this Mac, and it has never exited since. What it costs is about five megabytes of memory and five minutes of processor time across 25 days.

The folder at `~/Library/Caches/com.apple.nsurlsessiond/Downloads` names every app that has ever used it, which on this Mac was ten, from iCloud Drive and the App Store through to a Chrome build and a command line tool. They were all empty, because finishing means cleaning up.

And the timing that looks wrong is designed. An app can request a transfer run now, and that request only counts while the app is on screen. Once it is in the background, macOS decides when, prefers power and Wi-Fi, and records every attempt to override it. If a download is waiting, the answer is usually a cable and an open lid rather than a command.

## FAQ

### What is nsurlsessiond on my Mac?

It is the daemon behind background downloads. When an app starts a download that should survive the app being closed, it hands the job to nsurlsessiond, and the daemon keeps the connection open and writes the file even though the app that asked for it is no longer running. Its path is /usr/libexec/nsurlsessiond, which is Apple's own executable rather than something an app installed, and it also runs a second copy as a dedicated system account called _nsurlsessiond so that system level transfers do not depend on anyone being logged in.

### What is nsurlsessiond downloading?

There is a folder on your Mac that answers this exactly, and almost nobody knows it is there. In your home folder, Library, Caches, com.apple.nsurlsessiond, Downloads, macOS keeps one subfolder per app that has ever used a background session, named after the app's bundle identifier. On the Mac this was written on there were ten of them, including com.apple.bird for iCloud Drive, com.apple.cloudd for iCloud, com.apple.amsaccountsd for the App Store, com.apple.geoanalyticsd for Maps, plus Google Chrome for Testing, Perplexity's Comet browser and OpenAI's Codex. The folders were all empty, because the files inside them are removed once the transfer finishes. The folder stays as the session's bookmark, and the dates on them tell you when each app last used it.

### Why is nsurlsessiond using CPU or data at night?

Because Apple designs it to run when the machine is not busy. Transfers can be marked as discretionary, and Apple's own developer documentation says the system might delay transferring large files until the device is plugged in and connected over Wi-Fi, and that for transfers started while an app is in the background the system always schedules them at its own discretion. That is why a download you started in the afternoon can finish at 3am, and why Activity Monitor shows nsurlsessiond at the moment you were not looking. It is a scheduling decision, not a fault.

### Can I disable or stop nsurlsessiond on Mac?

You can quit it from Activity Monitor and it will come back the moment anything needs it, because it has no timer and no schedule to disable: it is started on demand through a mach service and a queue directory, and launchd keeps it alive. There is no Apple setting that turns the daemon off. What the settings do change is how much there is to download. In App Store settings, Automatic Updates makes the App Store download and install updates by itself, Automatically download apps purchased on other devices pulls things you bought elsewhere, and Automatically download in-app content runs apps in the background to fetch content before you first open them. In System Settings, General, Software Update, the small i button next to Automatic Updates holds Download new updates when available and Install macOS updates. Turning those off reduces the traffic without touching the daemon.

### Is nsurlsessiond a virus or malware?

No. It is present on every Mac, it lives in /usr/libexec, the binary is signed by Apple with an identifier of com.apple.nsurlsessiond, and the files you have to look at to confirm that are all readable without any special access. What makes people suspicious is the name, which is short for NSURLSession daemon and refers to an Apple programming interface called NSURLSession rather than to any file on your disk. A real malware author would have to replace an Apple signed executable in a protected system folder to impersonate it, which is a much harder thing to do than to write a new name nobody would search for.
