Fix it now
The password was accepted and the directory refused the bind anyway, because of the state the account is in. Each sub-code is a Windows status code in hexadecimal: 533 is account disabled, 532 is password expired, 701 is account expired, 773 is must change password, 775 is locked out. Every one of them is fixed on the account.
Get-ADUser <name> -Properties Enabled,LockedOut,PasswordExpired,PasswordLastSet,AccountExpirationDate
Search-ADAccount -AccountDisabled
Search-ADAccount -AccountExpired
Search-ADAccount -PasswordExpired
Search-ADAccount -LockedOut
- Match the sub-code to the state: 533 disabled, 532 password expired, 701 account expired, 773 must change password at next logon, 775 locked out.
- Apply the matching change –
Enable-ADAccount,Unlock-ADAccount,Clear-ADAccountExpiration, or set a new password – and nothing else. These states do not overlap, so fixing two at once tells you nothing about which one it was. - For 773, set the password to the value the application will use and then clear the flag with
Set-ADUser <name> -ChangePasswordAtLogon $false. An application cannot perform an interactive password change, so the flag simply blocks it. - Retry the bind against the domain controller the application uses, or wait for replication. Fixing the account on one controller and testing against another is the usual reason a correct fix looks like it failed.
Find out why the account went into that state before you reverse it. An account disabled during an incident should not be quietly switched back on because a service stopped working.
If the application connects, you are done. If it does not, or if the account goes straight back into the same state, the next section explains what puts it there.
Why it happens
All of these arrive as LDAP 49, LDAP_INVALID_CREDENTIALS, because that is the only bind refusal the protocol defines. The extended message that Active Directory adds carries a data value, and that value is a Windows status code written in hexadecimal. Once you read it that way the distinction is obvious: 52e is 1326, the user name or password is incorrect, while 533 is 1331, the account is disabled. The first is about a secret, the rest are about a state.
That distinction decides who fixes it. A 52e goes to whoever holds the credential. A 533, 532, 701, 773 or 775 goes to whoever administers the account, and no change to the application will make any difference. This is worth being firm about, because the application’s own error text almost always says something like “logon failed” and sends people looking at connection strings for an afternoon.
Service accounts produce most of these, and for structural reasons rather than by accident. An account created for an application inherits the domain password policy like every other account, so it expires on schedule. A leaver process that disables accounts in bulk catches service accounts named after people. An expiry date set for a project outlives the project. In each case the application worked perfectly the day before and nothing about it changed.
A routine process disabled the account
You have this one if Sub-code 533. The account is named after a person, or matches a pattern used by a leaver or cleanup script.
- Find out what disabled it and when, before re-enabling. The account’s own metadata and your identity management logs will usually say.
- Re-enable it:
Enable-ADAccount -Identity <name> - Move genuine service accounts into an organisational unit that your automated processes exclude, and give them descriptions that say what they are for.
- Run
Search-ADAccount -AccountDisabledafterwards to see whether the same run caught anything else you have not noticed yet.
The password expired under the domain policy
You have this one if Sub-code 532, arriving a predictable number of days after the account was created or last changed.
- Set a new password and update it in the application in the same change window, not afterwards.
- Decide deliberately how the account will be managed from here: a documented rotation, or a recorded exemption.
- Where an exemption is right, apply it through a fine-grained password policy against a group of service accounts rather than ticking a box on individual accounts.
- Check what policy actually applies to the account rather than assuming the default domain policy does.
Setting passwords never to expire on a scattering of individual accounts is how organisations end up with credentials nobody has changed in a decade and no list of which ones they are.
An account expiry date was set and forgotten
You have this one if Sub-code 701, usually on an account created for a contractor, a migration or a time-limited project.
- Read the date:
Get-ADUser <name> -Properties AccountExpirationDate - Clear it if the account is still needed:
Clear-ADAccountExpiration -Identity <name> - Extend it rather than clearing it where the limit was deliberate:
Set-ADAccountExpiration -Identity <name> -DateTime "2027-01-31" - Run
Search-ADAccount -AccountExpiringto find the next one before it takes something down.
The account is flagged to change its password at next logon
You have this one if Sub-code 773, typically within minutes of somebody resetting the password from a console.
- Set the password to the value the application will actually use.
- Clear the flag:
Set-ADUser <name> -ChangePasswordAtLogon $false - Retry the bind. Nothing else needs to change; the flag alone was blocking it.
- When resetting service account passwords in future, clear the change-at-next-logon box in the same action rather than as a follow-up.
The account is locked out and keeps re-locking
You have this one if Sub-code 775, and the account locks again within minutes of each unlock.
- Unlock it:
Unlock-ADAccount -Identity <name> - Find the source of the bad attempts before unlocking a second time. The failed logon records on the domain controller carry the client address.
- Check every host the application runs on, including ones that were supposedly decommissioned but left switched on, and any phone or laptop with the same account saved.
- Read the lockout threshold and observation window with
Get-ADDefaultDomainPasswordPolicyso you know how much room you have while testing.
Full reference
Each sub-code, and the command that clears it
| data value | Windows status code | Account state | What clears it |
|---|---|---|---|
533 |
1331 ERROR_ACCOUNT_DISABLED | The account is disabled | Enable-ADAccount -Identity <name> |
532 |
1330 ERROR_PASSWORD_EXPIRED | The password has passed its expiry | Set a new password, then update the application |
701 |
1793 ERROR_ACCOUNT_EXPIRED | The account itself has passed its expiry date | Clear-ADAccountExpiration -Identity <name> |
773 |
1907 ERROR_PASSWORD_MUST_CHANGE | The password must be changed before the account can sign in | Set-ADUser <name> -ChangePasswordAtLogon $false, after setting a known password |
775 |
1909 ERROR_ACCOUNT_LOCKED_OUT | The account is locked out | Unlock-ADAccount -Identity <name> |
Microsoft publishes those Windows status codes. It does not publish a page mapping the LDAP data field onto them, so treat any sub-code list that cannot be traced back to a status code as folklore.
Finding the accounts already in one of these states
Every one of these has a matching switch on the same cmdlet, and running them on a quiet afternoon is far more useful than running them during an outage.
| Command | What it returns |
|---|---|
Search-ADAccount -AccountDisabled |
Accounts whose Enabled property is false |
Search-ADAccount -AccountExpired |
Accounts whose expiry date is in the past |
Search-ADAccount -AccountExpiring |
Accounts expiring within a period you specify |
Search-ADAccount -PasswordExpired |
Accounts with an expired password |
Search-ADAccount -LockedOut |
Accounts currently locked out |
Search-ADAccount -AccountInactive |
Accounts that have not signed in within a period you specify |
Why the same account keeps coming back
- A password policy applies to the account and nobody owns the rotation, so it expires on the same cycle indefinitely.
- The account sits in an organisational unit that a cleanup or leaver process walks, and it will be caught again on the next run.
- Somebody resets the password from a console with the default options, which re-applies the change-at-next-logon flag every time.
- The credential is saved on more hosts than anybody has a list of, so an unlock is followed by another lockout from a machine nobody remembers.
- The application is a scheduled task or a service whose logon password is stored separately from the one in its configuration file, so half of it is updated and half is not.
Group managed service accounts, and where they do not help
Where an application supports it, a group managed service account removes this whole category: Windows rotates the password itself and there is no stored value to go stale. It is not a universal answer. There is no password a human can type into a third-party product’s settings page, so it suits Windows services and scheduled tasks rather than an appliance or a Java application that wants a credential in a file. Check the application’s documentation before promising anyone a migration.
Before you conclude the account is the problem
- Read the sub-code again. 52e is not on this list, and it means the credential is wrong rather than the account state – a different article and a different fix.
- Confirm you are reading the state on the domain controller the application binds to, using the
-Serverparameter. - Check whether a fine-grained password policy applies to the account rather than the default domain policy, because the expiry you are working from may be the wrong one.
- Confirm the application is not simply printing a generic message. Many print “invalid credentials” for every LDAP 49 and discard the extended message that carries the answer.
- If the account is genuinely fine and the bind still fails, look at whether the domain controller is refusing the bind for being unprotected, which reports as LDAP 8 rather than 49.
Every code this article covers
| Code | What it points at | Source |
|---|---|---|
LDAP 533 |
Windows status 1331, ERROR_ACCOUNT_DISABLED: this user cannot sign in because the account is currently disabled | Microsoft Learn |
LDAP 532 |
Windows status 1330, ERROR_PASSWORD_EXPIRED: the password for this account has expired | Microsoft Learn |
LDAP 701 |
Windows status 1793, ERROR_ACCOUNT_EXPIRED: the account itself has passed its expiry date | Microsoft Learn |
LDAP 773 |
Windows status 1907, ERROR_PASSWORD_MUST_CHANGE: the password must be changed before the account can sign in | Microsoft Learn |
LDAP 775 |
Windows status 1909, ERROR_ACCOUNT_LOCKED_OUT: the referenced account is locked out and may not be logged on to | Microsoft Learn |
Confirm the fix worked
Get-ADUser <name> -Properties Enabled,LockedOut,PasswordExpired,AccountExpirationDatereturns exactly the values you expect.- A manual bind with the application’s credential succeeds against the domain controller the application uses.
- The application restarts and connects with no error.
Search-ADAccount -LockedOutdoes not list the account again an hour later.- Nothing else in the same organisational unit turned up in the
Search-ADAccountsweeps, which would mean the process that caught this account caught others.
Questions people ask about this
Is there anything to buy to fix this?
No. Every fix here is a change to an account in a directory you already run, made with tools already installed. Treat any suggestion that this is a licensing problem with suspicion.
Should I set service account passwords never to expire?
It is a trade-off rather than a rule. It removes a recurring outage and it also removes any prompt to ever change the credential. If you do it, apply it through a fine-grained password policy against a group, record which accounts are covered, and review the list on a schedule.
Why does the application say the password is invalid when it is not?
Because everything in this family is reported as invalid credentials at the protocol level. Most applications print that text and throw away the extended message where the real reason is. Get the full message from the directory or from a manual bind.
How do I tell 532 from 773?
532 is 1330, the password has expired on its own schedule. 773 is 1907, somebody has flagged the account to change its password at next logon. They look identical to the application and the fixes differ: one needs a new password, the other needs the flag cleared as well.
The account unlocks and locks again immediately. Where do I look?
At the failed logon records on the domain controller, which carry the address of the client making the attempts. Until you have that address, unlocking again just restarts the cycle.
