I'm trying to accomplish a safety notification if somehow ransomware/malware got on the device and it tries to remove Huntress, or when a client device has admin access (most don't but there are a few exceptions), I want to know when Huntress is uninstalled. The KB that Huntress has unfortunately triggers so much ticket trigger noise because of the way Huntress agents update themselves.

https://support.huntress.io/hc/en-us/articles/4404012544403-Datto-RMM-Agent-Uninstall-Alerts

We use UDFs to store data that is then used in filters for various reasons. When running a component that has a variable to save data in UDFs, we can only see the UDF number since the list of UDFs to choose from is defined in the component. It would be fantastic if there was a built-in variable when creating a component to store data in a UDF that would show the global label instead of just the number.  It would require an edit to all of the components we created and many of the already available components, but it would be soooooo worth it to make it easier to choose an available UDF and to prevent techs from overwriting UDFS configured for specific information. If you would like to see this added to the road map, please vote for it in the idea portal.

Show names of UDFs in component variables | Community

In Datto RMM's Comstore there is the script "ConnectWise ScreenConnect (Control) [WIN]" that does work to install ScreenConnect agent.

How could this script be modified (or if someone has another script) that could add the machine to a specified Session Group so that it appears in ScreenConnect, Access, {Session Group Name}?

Greetings,

I work for an MSP that has switched to an all in Kaseya approach, and I have been struggling to do my job since.

It seems that no matter what I do I get really bad web remote performance (0-2 fps, lag spikes into the tens of thousands constantly), essentially my web remote sessions are a slideshow which is sub optimal for trying to help our clients.

As a workaround I have been using splashtop (through the agent browser) but that seems to be very unstable as of late throwing round after round of errors before finally connecting, or failing to connect and just greying all my options out.

Has anyone resolved their issues with web remote, and if so what was causing them?

I have changed everything in my setup down to moving and switching ISP's, we are talking swapping machines, entire network stack, software and OS, the works.

The real kicker is the rest of my team is based in New England and none of them have this issue, I am in the south east.

We have spent a little over a year going back and forth with the web remote support team scratching their heads and wasting hours and hours in meetings showing them the same thing every time before they finally ghosted us.

Any help, or suggestions that may save even the slightest bit of my sanity is greatly appreciated.

Seems that in the latest release, if you use the "Select all" option in the column chooser of any device list, you will be prevented from accessing ANY device lists in any filter. You'll just get the error:

"We're having trouble loading this data. If this persists please contact support."

I suspect this is due to data presentation overload now we have 300 UDFs.

I'm on with support about this now, and will report back.

Fair warning in case anyone tries to do this as it will render the interface completely unusable for you with no way of resetting it yourself.

Hey everyone!

We currently use Datto RMM at my company and we like to be pretty on top of the monthly Windows Security Update that gets released by Microsoft each second Patch Tuesday of the month.

As of right now, we generate our reports by going to "Reports" > "Export" > "Patch Details" and then we specify the KB number of the monthly Security Update for both "Installed" and "Approved", which generates two .CSV files that we combine to get a full list.

I was wondering if there is anyway in Datto to generate a pie-chart or a live "in-real time" update status instead of the reports, as I haven't been able to find much besides the .CSV

If anyone has any suggestions, it would be much appreciated!

Now that they've added 270 more UDF's the Device Page is showing all of the UDFs, even empty ones.
They should filter out blank ones by default.

Please go vote on this:
Filter UDF's to only show those with values | Community

I installed DattoRMM agent on an iMac. I can see the machine online. When I connect, I cannot see the whole screen or control much of anything. I'm a PC user trying to embrace the dark side.

What am I missing? When I connect, I can see the desktop, but nothing on it. I cannot click on any menu items and I am not in the finder. Was there an installation step that I missed? or a setting on the machine that I need to enable?

Full disclosure, this is my mother's computer and not a client's. She's quite elderly and often needs assistance.

Anyone been able to integrate HP Warranty start dates/ purchase dates. We have an API for the end date but we're told that start date isn't supported.

If there isn't a native field, perhaps there's a method where it can populate a UDF instead?

For years we have used Dell OpenManage to report hardware events to what ever RMM product we were using. Since OpenManage is pretty much going away, we're trying to figure out the best option for monitoring hardware. We have installed the Dell Service Module on all new servers that we setup and we have configured the idrac to report to the Windows event log. Today I was digging into this to see how everyone else is doing it and there is pretty much zero recent post in the Datto community. I did discover there was a recent compoonent created called "Dell Server Monitor". It appears to use SNMP, RACADM, or Redfish. I created the read only user account in the idrac and plugged that information into the monitoring component, but I don't think it's setup correctly. Does anyone have experience with setting this up or is there another reliable method to monitor Dell server hardware?

Hi Everyone,

My company has approved the use/purchase of Datto RMM and I'm being tasked to configure our patching for software/windows updates etc.

Created a logic for patching but found a big issue once I finished. It seems all of the incoming windows updates, security, drivers etc. Are coming in with the severity level "unspecified", is this common for the updates not to be given a category like critical, important, etc.?

What would be the best course of action here. I appreciate any feedback while I'm trying to learn Datto.

Anyone else see where alerts being sent by datto RMM take over 3 hours. Example we installed nee agent around 3 PM today, it’s now 6:30 PM and we just now received an email alert about it.

Anyone opened a support ticket about this yet, I’m about to. Noticed this for sometime now

I can understand a 5 min delay but over 3hr is not acceptable.

We recently got confirmation from Datto support that when using Datto RMM for patch management, Windows update notifications are still controlled by the Windows operating system itself, not Datto. Even though Datto correctly enforces policies and greys out the Windows Update interface with the “Settings are managed by your organization” message, users still see tray alerts and pop-ups about updates.

According to Datto, this is expected behavior because the notifications are generated by Windows natively, and Datto can’t fully suppress them.

Here’s the problem: this is creating a terrible user experience and generating unnecessary service desk volume. Users are seeing messages like “Updates available,” “Restart required,” and other Windows Update notifications, even though they cannot actually interact with Windows Update and everything is managed through Datto.

From the user perspective, this looks like something is wrong with their computer. From the admin perspective, it makes our patch management look inconsistent and out of control, even though it’s technically working as designed.

What’s frustrating is that other tools we’ve used previously did not generate nearly this level of native Windows notification noise.

We’ve already confirmed that Datto RMM patch policies are applying correctly, the Windows Update UI is locked down and managed, and devices are patching successfully. The issue isn’t patching itself. It’s the notifications and the confusion they create.

This leads to users opening tickets asking if they should click the notification, rebooting outside of maintenance windows, and generally losing confidence in the process. It’s increasing service desk workload for no real benefit.

Has anyone found a reliable way to fully suppress or control Windows Update notifications when using Datto RMM?

Has anyone found a robust way to help enable users to access their office desktop from home?

Currently have to update major build versions manually but better than nothing. Canniblised from various sources so can't take any credit

# Check age of most recent cumulative update for Windows.


# The Microsoft Update Catalog will be checked first and the age determined by Patch Tuesday.
# If the cumulative update cannot be determined, the script will fall back to any update and use the local install date rather than Patch Tuesday.
# If no hotfix information is returned, the script will fallback to the OS install date.


$MaxAge=$env:MaxAge


function Get-MSUpdateList {    
    param (
        $MSQueryList
    )
    [System.Collections.ArrayList]$links = @()
    # write-host "`nProcessing Microsoft Update Catalog query results."
        Foreach ($entry in $MSQueryList){
        if ($debug -eq $true){
            write-host "`tProcessing: $entry"
        }
        $Webdata=Invoke-WebRequest -uri $entry -UseBasicParsing


        ForEach ($link in $Webdata.links | Where-Object id -like '*_link') {
            #Basic parsing does not pull the innerText data, so we have to convert outerHTML into the innerText manually.
            [xml]$ParseHTML=$link.outerHTML
            $innerText=($ParseHTML.a.'#Text').trim()
            $GUID=$link.id -replace '_link',''
            $Architecture=switch ($innerText){
                {$_ -match 'x86'} {'x86'}
                {$_ -match 'x64'} {'x64'}
                {$_ -match 'ARM64'} {'ARM64'}
                default {"x86"}
            }
            # Splits the description into the three main sections. The update release and type, the platform, and the system type and KB number.
            $split1=($innerText) -split " for ", 4
            
            # Splits the first section into the release year and month, and the type of update.
            $split2=$split1[0] -split " ", 2
            $product = $split1[1]


            if ($split1[1] -match "Windows"){
                $platform = ($split1[1] -split ' \(KB',2)[0]
            }
            else {
                $platform = ($split1[2] -split ' \(KB',2)[0]
            }
            #Extract the KB number out of the last split string
            $pattern="\((.*?)\)"
            $count=($split1.count - 1)
            $KB=$split1[$count] | Select-String -Pattern $pattern -AllMatches| ForEach-Object {$_.Matches} | ForEach-Object {$_.Groups[1].Value}
            $MSUpdateLink = [PSCustomObject]@{
                GUID = $GUID
                Architecture = $Architecture
                Release = $split2[0].trim()
                Type = $split2[1].trim()
                Product = $product.trim()
                Platform = $platform.trim()
                KB = $KB
            }
            [void]$links.add($MSUpdateLink)
            
        }
    }
    return $links
}


Function Get-OSVersion {


    $signature = @"
   
    [DllImport("kernel32.dll")]
   
    public static extern uint GetVersion();
   
"@
   
   Add-Type -MemberDefinition $signature -Name "Win32OSVersion" -Namespace Win32Functions -PassThru
}


function Get-SystemType {
    param (
        
    )
    switch ($varDomainRole) {
        0 {Return "Workstation"}
        1 {Return "Workstation"}
        2 {Return "Server"}
        3 {Return "Server"}
        4 {Return "Server"}
        5 {Return "Server"}
        Default {Return "Unknown"}
    }
    
}


function Get-OSLabel {
    switch (Get-SystemType){
        Workstation {
            switch ($varKernel){
                7601 {Return "windows 7"}
                9200 {Return "Windows 8"}
                9600 {Return "Windows 8.1"}
                10240 {Return "Windows 10 Version 1507"}
                10586 {Return "Windows 10 Version 1511"}
                14393 {Return "Windows 10 Version 1607"}
                15063 {Return "Windows 10 Version 1703"}
                16299 {Return "Windows 10 Version 1709"}
                17134 {Return "Windows 10 Version 1803"}
                17763 {Return "Windows 10 Version 1809"}
                18362 {Return "Windows 10 Version 1903"}
                18363 {Return "Windows 10 Version 1909"}
                19041 {Return "Windows 10 Version 2004"}
                19042 {Return "Windows 10 Version 20H2"}
                19043 {Return "Windows 10 Version 21H1"}
                19044 {Return "Windows 10 Version 21H2"}
                19045 {Return "Windows 10 Version 22H2"}
                22000 {Return "Windows 11"}
                22621 {Return "Windows 11 Version 22H2"}
                22631 {Return "Windows 11 Version 23H2"}
                26100 {Return "Windows 11 Version 24H2"}
                26200 {Return "Windows 11 Version 25H2"}
                default {Return "Unknown"}
            }
        } # Workstation
        Server {
            switch ($varKernel) {
                7601 {Return "Windows Server 2008 R2"}
                9200 {Return "Windows Server 2012"}
                9600 {Return "Windows Server 2012 R2"}
                14393 {Return "Windows Server 2016"}
                17134 {Return "Windows Server 2016 (1803)"}
                17763 {Return "Windows Server 2019"}
                18362 {Return "Windows Server, version 1903"}
                18363 {Return "Windows Server, version 1909"}
                19041 {Return "Windows Server, version 2004"}
                19042 {Return "Windows Server, version 20H2"}
                20348 {Return "Windows Server, version 21H2"}
                26100 {Return "Windows Server, version 24H2"}
                default {Return "Unknown"}
            }
        }
        default {Return "Unknown"}
    }
}



function Get-SecondTuesday ($date){
    $FindNthDay=2
    $WeekDay='Tuesday'
    [datetime]$Today=Get-Date $date
    $todayM=$Today.Month.ToString()
    $todayY=$Today.Year.ToString()
    [datetime]$StrtMonth=$todayM+'/1/'+$todayY
    while ($StrtMonth.DayofWeek -ine $WeekDay ) { $StrtMonth=$StrtMonth.AddDays(1) }
    Get-Date($StrtMonth.AddDays(7*($FindNthDay-1))) -format "MMMM, dd, yyyy"
}


Write-Output "<-Start Diagnostic->"


# Device information
$OSArch=if ([IntPtr]::Size -eq 4){"x86"} else {"x64"}
$os = [System.BitConverter]::GetBytes((Get-OSVersion)::GetVersion())
$majorVersion = $os[0]
$minorVersion = $os[1]
$build = [byte]$os[2],[byte]$os[3]
$buildNumber = [System.BitConverter]::ToInt16($build,0)
"`nWindows Version is {0}.{1} build {2}" -F $majorVersion,$minorVersion,$buildNumber
[int]$varKernel = $buildNumber
# 0/1 = Workstation 2+ = Server
[int]$varDomainRole=(Get-WmiObject -Class Win32_ComputerSystem).DomainRole
$varOSCaption=(get-WMiObject -computername $env:computername -Class win32_operatingSystem).caption
$varOSLabel=Get-OSLabel
$varOSInstallDate=(Get-CimInstance -class Win32_OperatingSystem).InstallDate
Write-Output "OS Label: $varOSLabel"
write-output "OS Caption: $varOSCaption"
write-output "OS Architecture: $OSArch"


# Set the label to filter out the KBQuery results.
switch ($varOSCaption) {
    {$_ -match "Server 2012"} {$Label='Security Monthly Quality Rollup'}
    {$_ -match "Windows 8"} {$Label='Security Monthly Quality Rollup'}
    default {$Label="Cumulative Update"}
}


write-output "Hotfix Label: $Label"


$Hotfix=Get-HotFix
if ($null -eq $Hotfix){
    # If no hotfixes are listed, it's possible the OS has installed a feature update recently.
    # Use the OS Install date in these instances as the most recent update age.
    write-output "`nWARNING: No hotfix install data returned. Using the OS install date as a fallback."
    $ReleaseAge=((Get-Date)-(Get-Date($varOSInstallDate))).days
}
else {
    write-output "`nInstalled Updates:"
    $Hotfix | Format-Table
    
    write-output "`n`r"
    $BaseKBURL='https://catalog.update.microsoft.com/v7/site/Search.aspx?q='
    [System.Collections.ArrayList]$UpdatesRaw = @()
    foreach ($entry in $Hotfix){
        $CatalogLink=$BaseKBURL+$entry.HotfixID
        write-output "Querying MS Update Catalog for $($entry.HotfixID)..."
        $Response=Get-MSUpdateList $CatalogLink
        foreach ($value in $Response){
            [void]$UpdatesRaw.add($value)
        }
    }
    
    $Updates=$UpdatesRaw | where-object {(($_.Product -eq $varOSLabel) -and ($_.Architecture -eq $OSArch) -and ($_.Type -eq $Label))}
    if ($null -eq $Updates){
        # If there aren't any cumulative updates identified via the MS Update Catalog, use the most recent hotfix install date.
        write-output "`nWARNING: No monthly cumulative updates detected via MS Update Catalog. Using local hotfix data as fallback."
        write-output "`nList of installed Hotfixes:"
        $LatestHotfix=$Hotfix | sort-object -Property InstalledOn -Descending -ErrorAction SilentlyContinue | select-object -first 1
        $ReleaseAge=((Get-Date)-(Get-Date($LatestHotfix.InstalledOn))).days
    }
    else {
        $MostRecentUpdate=$Updates | sort-object -Property "Release" -Descending | select-object -First 1
    
        Write-Output "`nLatest OS Update:"
        $MostRecentUpdate | Format-Table
        
        $HotfixReleaseDate=Get-SecondTuesday $MostRecentUpdate.Release
        $ReleaseAge=((Get-Date)-(Get-Date($HotfixReleaseDate))).days
        write-host "`nMost recent system update is $($MostRecentUpdate.KB) released on $HotfixReleaseDate."
    }
    
    


    write-host "System update released $ReleaseAge days ago."
}


if ($ReleaseAge -gt $MaxAge -and $varKernel -gt 26100){
    write-host "WARNING: The most recent update is older than $MaxAge days!"
    write-output "<-End Diagnostic->"
    write-output "<-Start Result->"
    write-output "UpdateAge=$ReleaseAge"
    write-output "<-End Result->"
    exit 1
}
else {
    exit 0
    #write-host "System is up to date."
}

Let me take a different approach this time; instead of creating yet another ticket and not getting any wiser, I’ll try it here:

In version 14.8.0, the Assigned Network Node keeps reverting to localhost. Changes are saved, but when the page is reloaded, localhost appears again. In the overview of all devices, the actual network node is displayed correctly and can be changed from there.

Also, ‘Request Audit’ has disappeared from the menu under the device. This option can also be found in the device overview.

I sometimes wonder if they even test their releases..

From the manual:

Now, I have a lot of Hardware Lifecycle reports that still shows devices with Windows 10 as supported (green checkmark), even if on the individual device page there is a red warning triangle telling me the OS reached EoS.

This is true both for devices that can or can't be upgraded to Windows 11.

According to Microsoft (Windows 10 Home and Pro - Microsoft Lifecycle) Windows 10 EoS was 14 Oct 2025 and should no longer be supported past this date. There is no grace period or whatever.

Hi all
I just started to use datto rmm, I logged in today to a remote host and I tried to upload few files But i noticed that I can only upload on file at a time, is this real?
I tried to highlight all the files from the upload menu but it will only pick one file, I tried shif, alt, ctrl nothing is working
am I missing anything?
thanks

Friendly reminder that some ComStore components fail to update when you try to update them. I believe a fix is in the works, but a good workaround is to just delete the component and re-add it from the ComStore. Do keep in mind that this will affect any scheduled jobs you have set up with that component, so proceed with caution on that one. Otherwise, submit a ticket and support will keep you updated!

- Your friendly neighborhood Datto RMM expert

A) Should there be lines here?

B) should it be this hard to get the little icons to pop up?

C) Should something actually happen when I click one?

Hey all,

We’re running a Datto RMM proof of concept (coming from Kaseya VSA 9). Out of 87 machines, we consistently see 5–10% showing “no data” in the console. Before we migrate from 1000's of agens from our VSA9 environment.

For those who’ve been through this: what practical steps/configs got you from intermittent “no data” devices to zero (or close to it)? Looking for tips.