Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Rearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.
A Windows Server Evaluation install starts a 180-day clock the moment it first boots, and that clock is not a polite reminder. At day 181 the box reboots hourly, shows a desktop watermark, and stops accepting most updates. Ten reboots an hour is enough to break any service that expects to stay up, which is why the grace period has to be planned rather than discovered.
The counter lives in the software licensing service, not in the registry date you can see in winver. Reading it properly takes one command, and the number it returns is the only figure worth planning against. Everything else — the marketing “180 days”, the rearm folklore, the blog posts promising two years — is secondary to that output.
For teams standing up a staging box on a Windows VPS, the eval image is often the fastest way to a working Server 2022 build with no key. The cost is a deadline, and a migration that crosses that deadline badly costs more than the licence would have.
Reading the clock correctly
Run slmgr /dlv in an elevated prompt. Look at the “Remaining Windows rearm count” and “Time remaining” lines. Time remaining is in minutes and it decrements whether or not the VM is running — it is wall-clock, not powered-on time, so a suspended instance still burns days.
A box reporting 259200 minutes is at day zero. When it drops under 43200 (30 days) you should already have the licence in hand. Under 10080 it is a page-one incident for whoever owns the workload, because the hourly reboot window starts at expiry, not at a warning you can snooze.
slmgr /dlv
# key lines:
# Time remaining: 259200 minute(s)
# Remaining Windows rearm count: 6
# quick check without the dialog
cscript //nologo C:\Windows\System32\slmgr.vbs /xprRearm limits, per SKU
Rearm resets the 180-day counter. The number of times you may rearm is fixed per SKU and is visible in the same /dlv output. Standard and Datacenter evaluation images commonly ship with a small remaining rearm count — often six for retail media, fewer on OEM-derived images — and each rearm consumes one.
Do not assume a rearm is available just because the command exists. If the count reads zero, slmgr /rearm returns an error and reboots the box for nothing. Check counts before relying on them, and never let a scheduled rearm script run blind at 02:00 on a production host.
| Action | Effect on clock | Reboot | Limit | Notes |
|---|---|---|---|---|
| Initial activation | Starts 180 days | No | Once | Set at build time |
slmgr /rearm | Resets to 180 days | Yes | Per-SKU count | Check count first |
| Disk restore / snapshot revert | No reset | No | — | Clock keeps running |
| Sysprep generalize | Resets activation state | Yes | 1–3 typically | Breaks some app configs |
| Insert licence key | Converts to retail | Yes (recommended) | 1 | No reinstall needed |
| Expiry reached | Hourly reboot | Hourly | — | Logs stop, apps die |
Two rows deserve a note. A snapshot revert does not give you the clock back: the licence service reads the tick count from the guest’s own store, and rolling back to a day-20 image after 100 days of uptime restores day-20 files but not day-20 licensing state, because the sealed machine identifier and the rearm counter travel with the disk. The same applies to a clone — a copied VHDX inherits the counter, so two boxes built from one eval image share the same deadline.
What expiry actually does
The hourly shutdown starts on the hour boundary and the system cannot log you out gracefully. Services get the standard shutdown notification, agents that buffer to disk survive, agents that write straight to a remote API lose the in-flight second. Monitoring pages at roughly one per hour, forever.
Activation also fails, so Windows Update stops installing new patches and the licence notification appears on every interactive sign-in. The workload keeps running between reboots — this is not a lockout — but the availability profile is that of a machine with a power fault.
Converting without reinstalling
You can move an evaluation install to a licensed one in place. Run DISM /online /Set-Edition:ServerStandard /ProductKey:XXXXX-... /AcceptEula with a valid KMS client or retail key, then reboot. The filesystem, apps, IIS sites and registry stay where they are.
Two caveats. The edition key must match the edition family you are converting to — Standard keys will not lift a Datacenter image. And on some builds the conversion fails with error 50 or 0x80070490 unless pending updates are applied first, so run sfc /scannow and finish Windows Update before attempting it.
# order that fails least often
slmgr /ipk
DISM /online /Set-Edition:ServerStandard /ProductKey: /AcceptEula
Restart-Computer
slmgr /ato
slmgr /xpr Planning a migration across the deadline
If the eval box is temporary, treat day 150 as the cutover date regardless of what you promised the business. Image it, build the licensed target, and cut over while both boxes are healthy — not on the morning the hourly reboots start and every decision is made under pressure.
Snapshot before any conversion attempt, because a failed Set-Edition can leave the image in a state that boots but refuses activation. Keep the licence key in the password manager, not in a wiki page the one person who left can no longer read.
Why “two years of eval” is wrong
The claim comes from multiplying 180 days by a rearm count. It assumes every rearm succeeds, that activation state survives each reboot, and that nothing else resets the counter — three assumptions that break in a VM that gets restored from snapshot. Use the number that /dlv reports today, subtract 30 days, and treat that as the real deadline.
If eval is a stopgap, the cheapest fix is usually a licensed image at build time rather than a heroics conversion later. Check which Windows VPS plans ship a licensed image before you commit 180 days of config work to an install that expires on a fixed date.