How to Check PC/SC Reader Status and Reader Communication
← Back to the ACS testing and utilities centre
How do you check PC/SC reader status on Windows? Run three checks in order. First, confirm the Windows Smart Card service (SCardSvr) is running with sc query SCardSvr. Second, list the readers as PC/SC sees them, with certutil -scinfo, ACS QuickView or a few lines of code. Third, read each reader's state (empty, card present, in use by another program) and, with a card on the reader, check that its ATR is reported. If all three pass, software can talk to the reader.
This guide starts where Windows detection ends. Device Manager can show a healthy reader while card software still says "no reader found", because programs do not talk to the USB device directly: they go through the Smart Card service. Here you check that layer, read the PC/SC reader states and error codes, and see how Remote Desktop changes which readers a program sees. Every check is read-only and works for any ACS PC/SC reader, such as the ACR1252U, ACR1552U, ACR122U or ACR39U. BSD Infotech is an independent ACS supplier and integrator, not the manufacturer.
What PC/SC and the Smart Card Service Are
PC/SC (Personal Computer/Smart Card) is the standard way a computer program talks to a smart card reader. Windows reader drivers are written to it, and the same idea exists on macOS and Linux (pcsc-lite). Because of PC/SC, one program can work with readers from different makers without a separate driver API for each one.
On Windows, the centre of PC/SC is the smart card resource manager: the Smart Card service, whose service name is SCardSvr. It keeps the list of readers, tracks when cards arrive and leave, and decides which program may use a card at a given moment. Programs reach it through winscard.dll, Microsoft's PC/SC library.
It helps to think of four layers. A check passes only if every layer below it works:
| Layer | What it does | How you check it |
|---|---|---|
| 1. USB and driver | Windows recognises the reader and loads a driver | Device Manager, Smart card readers: see checking whether Windows detects the reader and the driver installation guide |
| 2. Smart Card service | The resource manager that every PC/SC program depends on | sc query SCardSvr or Get-Service SCardSvr (below) |
| 3. PC/SC reader list and states | The readers the service offers to programs, and whether each holds a card | certutil -scinfo, ACS QuickView or the C# check |
| 4. Card communication | A program connects to the card and exchanges commands | ATR shown, then a read-only command such as Get UID (below) |
Check 1: Is the Smart Card Service Running?
Plug the reader in first. Microsoft sets the service to start when a reader is connected, so it is normal for it to show Stopped while no reader is plugged in. With a reader attached it should be Running. These commands only read the status, so a normal (non-administrator) window is enough.
Language: Windows Command Prompt and Windows PowerShell 5.1. Prerequisites: none; built into Windows 10 and 11.
Not yet tested with an ACS reader. We ran these commands on a Windows 11 PC without an ACS reader to confirm the output format. The output with each ACS reader is still to be recorded.
:: Command Prompt
sc query SCardSvr
# PowerShell
Get-Service SCardSvr | Select-Object Name, DisplayName, Status, StartType
Expected result: sc query prints a STATE line that ends in RUNNING. Get-Service shows the display name Smart Card, Status Running and a StartType of Manual or Automatic. In the Services console (services.msc) you see the same thing on the Smart Card line.
If it fails: STOPPED with the reader plugged in, or a StartType of Disabled, means no PC/SC program can see any reader. How to start the service, set the right startup type and restart it is covered step by step in the Smart Card service section of the driver guide. On a company PC, ask IT first: a policy may have disabled the service on purpose.
Check 2: List the Readers PC/SC Can See
Device Manager lists hardware. PC/SC keeps its own list: the readers the Smart Card service offers to programs. Those two lists usually match, but not always (a driver that loaded without registering a PC/SC reader, a stopped service, or a Remote Desktop session). Your card software can only use readers on the PC/SC list. There are three ways to see it.
Option A: certutil -scinfo (built into Windows)
Microsoft uses this command in its own documentation to check which smart card readers a session can see. Open Command Prompt or PowerShell and run:
certutil -scinfo -silent
Read only the first block. It says whether the Microsoft Smart Card Resource Manager is running, gives the number of readers, lists each reader name, and then shows each reader's status line, for example SCARD_STATE_EMPTY, or SCARD_STATE_PRESENT followed by the card's ATR. Those status names are the PC/SC reader states explained below. Everything after that block is about certificates on identity cards and does not apply to MIFARE, NTAG, DESFire or memory cards; if a PIN prompt appears, cancel it. Our Windows detection guide walks through the rest of the certutil output.
Use exactly this command. The -scinfo option also accepts extra arguments, and one of them (CRYPT_DELETEKEYSET) deletes the keys on the card. Never add arguments you have not checked in Microsoft's certutil reference.
Option B: ACS QuickView (no command line)
ACS QuickView, free from the ACS utility tools page, lists the PC/SC readers it finds and shows reader and card details. ACS describes it as a polling tool too, so you can watch the card status change as you insert or remove a card. It is available for Windows, macOS and Linux. Close QuickView before you run your own program: while it is connected to a card, another program may not get access (see reader states). The testing and utilities centre compares QuickView with the other ACS tools.
Option C: ask PC/SC from your own code
If you are writing software, check from code exactly what your program will see. The C# status check below calls the same three Windows functions that every PC/SC program uses.
What ACS reader names look like
Each reader appears under a name chosen by its driver, ending in an index number. Some ACS readers appear more than once because they have more than one interface: the ACR1252U, for example, has a contactless (PICC) entry and a separate entry for its SAM slot. Pick readers by part of the name, never by position in the list. The model SDK pages give the names ACS documents for the ACR1252U, ACR1552U and ACR122U. A computer may also list readers that are not ACS hardware, such as a laptop's built-in reader or a Windows Hello virtual smart card.
C# Example: List PC/SC Readers and Their Status (.NET 8)
Language: C# 12 on .NET 8, Windows only (P/Invoke to winscard.dll; no NuGet packages). Prerequisites: Windows 10 or 11 and the .NET 8 SDK. Run dotnet new console, replace Program.cs with the code below, then dotnet run. The program is read-only: it calls SCardEstablishContext, SCardListReaders and SCardGetStatusChange, prints each reader's state and ATR, and releases the context. It never connects to a card and sends no commands.
Not yet tested on hardware. BSD Infotech has compiled this on .NET 8 and run it on a Windows 11 PC with no ACS reader attached, where it correctly listed the PC's built-in virtual smart card reader and its state. It has not yet been run with an ACS reader and a card. Treat it as a starting point.
// PC/SC reader status check. C# 12, .NET 8, Windows only (winscard.dll). Not yet tested on hardware.
// Read-only: it lists the readers and asks the Smart Card service for each reader's state.
// It never connects to a card and sends no commands.
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
const uint SCARD_SCOPE_USER = 0;
const int SCARD_E_NO_READERS_AVAILABLE = unchecked((int)0x8010002E);
int rc = WinScard.SCardEstablishContext(SCARD_SCOPE_USER, IntPtr.Zero, IntPtr.Zero, out IntPtr ctx);
if (rc != 0)
{
Console.WriteLine($"1. Smart Card service: NOT reachable (SCardEstablishContext returned 0x{rc:X8}).");
return;
}
Console.WriteLine("1. Smart Card service: reachable.");
try
{
// 2. Ask PC/SC for every reader it knows about.
uint chars = 0;
rc = WinScard.SCardListReaders(ctx, null, null, ref chars);
if (rc == SCARD_E_NO_READERS_AVAILABLE)
{
Console.WriteLine("2. Readers: none (0x8010002E, SCARD_E_NO_READERS_AVAILABLE).");
return;
}
if (rc != 0) { Console.WriteLine($"2. SCardListReaders failed: 0x{rc:X8}"); return; }
var buf = new char[chars];
rc = WinScard.SCardListReaders(ctx, null, buf, ref chars);
if (rc != 0) { Console.WriteLine($"2. SCardListReaders failed: 0x{rc:X8}"); return; }
string[] readers = new string(buf, 0, (int)chars).Split('\0', StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"2. Readers: {readers.Length}");
// 3. Ask the current state of each reader. dwCurrentState = 0 (SCARD_STATE_UNAWARE)
// and a time-out of 0 make SCardGetStatusChange return at once.
var states = new WinScard.SCARD_READERSTATE[readers.Length];
for (int i = 0; i < readers.Length; i++)
states[i] = new WinScard.SCARD_READERSTATE { szReader = readers[i], rgbAtr = new byte[36] };
rc = WinScard.SCardGetStatusChange(ctx, 0, states, (uint)states.Length);
if (rc != 0) { Console.WriteLine($"3. SCardGetStatusChange failed: 0x{rc:X8}"); return; }
foreach (var s in states)
{
Console.WriteLine($" {s.szReader}");
Console.WriteLine($" state: {Describe(s.dwEventState)}");
if (s.cbAtr > 0 && s.cbAtr <= 36)
Console.WriteLine($" ATR: {Convert.ToHexString(s.rgbAtr, 0, (int)s.cbAtr)}");
}
}
finally { WinScard.SCardReleaseContext(ctx); }
static string Describe(uint st)
{
// Flag values from winscard.h (SCARD_STATE_*).
var names = new List<string>();
if ((st & 0x0004) != 0) names.Add("UNKNOWN (reader name not recognised)");
if ((st & 0x0008) != 0) names.Add("UNAVAILABLE");
if ((st & 0x0010) != 0) names.Add("EMPTY (no card)");
if ((st & 0x0020) != 0) names.Add("PRESENT (card in the field or slot)");
if ((st & 0x0080) != 0) names.Add("EXCLUSIVE (another program has the card to itself)");
if ((st & 0x0100) != 0) names.Add("INUSE (another program is connected, sharing is possible)");
if ((st & 0x0200) != 0) names.Add("MUTE (card does not respond)");
if ((st & 0x0400) != 0) names.Add("UNPOWERED (card not powered yet)");
return names.Count == 0 ? "no state flags set" : string.Join(", ", names);
}
static class WinScard
{
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SCARD_READERSTATE
{
public string szReader;
public IntPtr pvUserData;
public uint dwCurrentState;
public uint dwEventState;
public uint cbAtr;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 36)]
public byte[] rgbAtr;
}
[DllImport("winscard.dll")]
public static extern int SCardEstablishContext(uint scope, IntPtr reserved1, IntPtr reserved2, out IntPtr context);
[DllImport("winscard.dll")]
public static extern int SCardReleaseContext(IntPtr context);
[DllImport("winscard.dll", EntryPoint = "SCardListReadersW", CharSet = CharSet.Unicode)]
public static extern int SCardListReaders(IntPtr context, string? groups, char[]? readers, ref uint chars);
[DllImport("winscard.dll", EntryPoint = "SCardGetStatusChangeW", CharSet = CharSet.Unicode)]
public static extern int SCardGetStatusChange(IntPtr context, uint timeoutMs,
[In, Out] SCARD_READERSTATE[] readerStates, uint count);
}
Expected result: line 1 says the service is reachable, line 2 gives the number of readers, and each reader follows with its state. With an ACS contactless reader and no card you should see EMPTY; with a card on it, PRESENT plus an ATR in hex. A reader with two interfaces appears twice. If another program is connected to the card at the same time, INUSE or EXCLUSIVE appears as well.
If it fails: "NOT reachable" with 0x8010001D or 0x8010001E means the Smart Card service is not running (Check 1). "Readers: none" (0x8010002E) means the service runs but no reader is registered: go back to Windows detection. Inside a Remote Desktop session, see Remote Desktop. Other codes are in the error code table.
To keep watching instead of taking one snapshot, call SCardGetStatusChange in a loop: copy each dwEventState into dwCurrentState and pass a time-out, and the call returns when a card arrives or leaves. Microsoft also documents a special reader name, \\?PnP?\Notification, that makes the call return when a reader is plugged in.
Reader States and What They Mean
The Smart Card service reports each reader's state as a set of flags. certutil prints them by name (for example SCARD_STATE_PRESENT | SCARD_STATE_INUSE), and the C# check above translates them. These are the ones you will meet:
| State | Meaning | What it tells you |
|---|---|---|
| SCARD_STATE_EMPTY | No card in the reader | Reader and service work. Place a card to test further. |
| SCARD_STATE_PRESENT | A card is in the reader (in the slot, or in the field of a contactless reader) | The reader has seen the card. With an ATR shown, the reader has also had a first exchange with it. |
| SCARD_STATE_UNPOWERED | The card is present but not powered up | Often normal while no program is connected to the card. |
| SCARD_STATE_INUSE | One or more other programs are connected to the card, but it can still be shared | Your program can connect in shared mode. If it asks for exclusive access, it will fail. |
| SCARD_STATE_EXCLUSIVE | Another program has taken the card for its own exclusive use | Nothing else can connect until that program lets go. This is the usual cause of "another program is using the reader". |
| SCARD_STATE_MUTE | There is a card, but it does not respond | Card not supported by this reader, damaged, or badly placed. Try another card of a type the reader supports. |
| SCARD_STATE_UNAVAILABLE | The reader's actual state is not available | Unplug and replug the reader; check Device Manager for a warning mark. |
| SCARD_STATE_UNKNOWN | The reader name is not recognised by the service | The reader was removed, or your program is using an old or mistyped name. List the readers again. |
"Another program is using the reader"
PC/SC lets several programs use one reader, but only one at a time can talk to the card when a program asks for exclusive access. If your program gets SCARD_E_SHARING_VIOLATION (0x8010000B), or the state shows EXCLUSIVE, something else holds the card. Usual suspects: another test tool (QuickView, Script Tool, a BSD utility), a second copy of your own program, a background card monitor such as the ACS Reader Monitor Program (ACS describes it as connecting to cards automatically), or a browser bridge used by a web card tool.
- Close every card program you can see, including its icon in the notification area.
- Check Task Manager for a second copy of your own program.
- Run the status check again. The INUSE or EXCLUSIVE flag should be gone.
- If you cannot find the program, restarting the Smart Card service ends every PC/SC connection (see the service section of the driver guide). Programs that were connected must then be reopened.
In your own code, connect in shared mode unless you really need exclusive access, and always disconnect and release the context, even after an error. A program that crashes while holding the card can leave the reader blocked until it is closed.
Check 3: Can Software Talk to a Card on the Reader?
Reader status proves the reader and the service work. Reader communication goes one step further: a program connects to the card and gets an answer to a command.
- Place a card the reader supports. Use a contactless card such as MIFARE Classic, NTAG or DESFire on the ACR1252U, ACR1552U or ACR122U, or a contact chip card in the ACR39U. The state should change from EMPTY to PRESENT.
- Look for an ATR. certutil, QuickView and the C# check all show it. A contact card sends its ATR (Answer To Reset) when the reader powers it up. For contactless cards, PC/SC readers report an ATR-style value that the reader builds from what it learned about the card. Either way, an ATR means the reader has exchanged data with the card. No ATR while the state is PRESENT, or a MUTE state, points to the card rather than to PC/SC.
- Send one read-only command. The usual test is Get UID (
FF CA 00 00 00), which ACS readers answer with the card's UID followed by90 00. You can send it in the free ACS Script Tool. For working code, use the model SDK guides: the ACR1252U SDK guide, the ACR1552U SDK guide and the ACR122U SDK guide each include a .NET 8 example that reads a card UID.
If Get UID returns the UID and 90 00, the whole chain works: driver, service, PC/SC and the reader's communication with the card. A failure after that point is in the card (type, keys, data) or in the application, not in PC/SC.
Common PC/SC Error Codes
Windows PC/SC functions return these values. The names and meanings are Microsoft's (Smart Card Return Values); the last column is our practical reading for ACS readers. Some programs print the same value as a negative decimal number: 0x8010002E, for example, appears as -2146435026.
| Code and value | Microsoft's meaning (summarised) | What it usually means in practice |
|---|---|---|
SCARD_E_NO_SERVICE0x8010001D | The smart card resource manager is not running | Smart Card service stopped or disabled. Start it (Check 1). |
SCARD_E_SERVICE_STOPPED0x8010001E | The resource manager has shut down | The service stopped or restarted while your program was using it. Release the context, then establish a new one. |
SCARD_E_NO_READERS_AVAILABLE0x8010002E | No smart card reader is available | Service running, but no reader registered. Check the USB connection and driver, or Remote Desktop redirection. |
SCARD_E_READER_UNAVAILABLE0x80100017 | The specified reader is not currently available | Reader unplugged or reset while in use. Replug it and list the readers again. |
SCARD_E_UNKNOWN_READER0x80100009 | The specified reader name is not recognised | Your program uses a stored or hard-coded name that no longer matches. Pick the reader from a fresh list. |
SCARD_E_NO_SMARTCARD0x8010000C | The operation needs a card, but none is in the device | No card on the reader when connecting. Place the card first, or wait for PRESENT before connecting. |
SCARD_W_REMOVED_CARD0x80100069 | The card has been removed, so further communication is not possible | The card left the field or slot during the exchange. Hold contactless cards flat and still. |
SCARD_W_RESET_CARD0x80100068 | The card was reset | Another program reset the card while you were connected. Reconnect. |
SCARD_W_UNRESPONSIVE_CARD0x80100066 | The card is not responding to a reset | Card not supported, faulty, or upside down in a contact reader. Try a known good card. |
SCARD_W_UNPOWERED_CARD0x80100067 | Power has been removed from the card | The card lost power during the exchange. Reconnect; check the USB port and cable. |
SCARD_E_SHARING_VIOLATION0x8010000B | The card cannot be accessed because of other outstanding connections | Another program holds the card. See "Another program is using the reader". |
SCARD_E_PROTO_MISMATCH0x8010000F | The requested protocols are incompatible with the protocol in use | Request both T=0 and T=1 when connecting unless you know the card's protocol. |
SCARD_E_NOT_READY0x80100010 | The reader or card is not ready to accept commands | Wait a moment after the card arrives, then retry. |
SCARD_E_TIMEOUT0x8010000A | The user-specified time-out has expired | Normal when waiting for a card with SCardGetStatusChange and none arrived. Not a fault. |
SCARD_F_COMM_ERROR0x80100013 | An internal communications error has been detected | Communication with the reader failed. Replug the reader, try another USB port, check the driver. |
SCARD_E_COMM_DATA_LOST0x8010002F | A communications error with the card has been detected | Card moved or poor contact. Retry with the card held still or reinserted. |
SCARD_E_INVALID_HANDLE0x80100003 | The supplied handle was not valid | Your code used a context or card handle after releasing it, or after the service restarted. |
SCARD_E_INSUFFICIENT_BUFFER0x80100008 | The buffer for returned data is too small | Ask for the needed size first (as the C# check does for the reader list), then call again. |
ERROR_BROKEN_PIPE0x00000109 | A smart card operation was attempted in a remote session on an operating system that does not support smart card redirection | Remote session without smart card redirection support. See Remote Desktop. |
Codes from card commands are different: a status word such as 90 00 (success) or 63 00 comes from the card or reader inside a successful SCardTransmit call. The model SDK pages list the status words for each reader.
Remote Desktop: Which Readers a Session Sees
Remote Desktop changes the answer to "which readers are there?". Microsoft documents smart card redirection: in a remote session, smart card calls are passed back to the readers connected to the computer you are sitting at (the Remote Desktop client), not handled by the remote computer alone. The decision is made for each PC/SC context, based on the session of the program that calls SCardEstablishContext.
- Your program runs in a remote session: plug the reader into the computer you connect from, and make sure smart card redirection is allowed. A reader plugged into the remote computer itself may not be the one your program sees in the session.
- Redirection is on by default. Microsoft lists the RDP setting
redirectsmartcards:i:1(smart cards on the local device are available in the remote session) as the default. - Administrators can block it. The Group Policy setting Do not allow smart card device redirection (Computer Configuration, Administrative Templates, Windows Components, Remote Desktop Services, Remote Desktop Session Host, Device and Resource Redirection) turns it off for the remote computer.
- Test it the way Microsoft does: run
certutil -scinfoinside the remote session. If redirection works, the output starts with the resource manager running and lists the client's readers. - Error
ERROR_BROKEN_PIPE(0x00000109) fromSCardEstablishContextmeans the program tried smart card operations in a remote session on a system that does not support redirection.
For a kiosk, counter or POS PC that runs card software locally, none of this applies. It matters when the card application is published through Remote Desktop, a terminal server or a virtual desktop.
Troubleshooting PC/SC Reader Status
Work from the top: a problem higher in the table hides the ones under it.
| What you see | Likely cause | What to do |
|---|---|---|
| Reader missing from Device Manager | USB, cable or driver problem (below PC/SC) | Follow the Windows detection checks, then the driver installation guide. |
Reader in Device Manager, but certutil or your program says "no reader" or returns 0x8010001D | Smart Card service stopped or disabled | Check 1, then start the service as shown in the driver guide. |
Service running, 0x8010002E (no readers) | Reader not registered with PC/SC, or you are in a Remote Desktop session | Replug the reader. In a remote session, connect the reader to the client computer and check redirection. |
| Reader listed, state stays EMPTY with a card on it | Card type not supported by this reader, or card badly placed | Use a card type the reader supports; hold contactless cards flat in the centre. On an ACR1552U, check it is not in keyboard emulation mode (see the testing centre). |
| State PRESENT but MUTE, or no ATR | Card does not answer the reader | Try a second, known good card. For contact cards, insert chip first and face up. |
State shows EXCLUSIVE, or connect returns 0x8010000B | Another program holds the card | Close other card software; see "Another program is using the reader". |
| Works in QuickView but not in your program | Code issue: wrong reader name, wrong share mode or protocol, handles not released | Compare with the read-only C# check above and the examples in the smart card SDK guide. |
Works for a while, then 0x8010001E or 0x80100003 | Service restarted or reader replugged while your program held old handles | Catch these codes, release everything, establish a new context and list the readers again. |
Sources
Windows function names, reader states, error code values and Remote Desktop behaviour were checked in Microsoft's documentation on 16 Nov 2026. ACS tool names and descriptions were checked on the ACS utility tools page on the same day.
- Microsoft: Smart Card Return Values
- SCardEstablishContext, SCardListReaders, SCardGetStatusChange and SCARD_READERSTATE (Microsoft Win32 reference)
- Microsoft: Smart Cards for Windows service and Smart Card Architecture
- Microsoft: Smart Card and Remote Desktop Services, Configure smart card redirection over RDP and Supported RDP properties
- Microsoft: certutil command reference (-scinfo)
- ACS Utility Tools (QuickView, Script Tool, Reader Monitor Program)
BSD Infotech is an independent ACS supplier and integrator, not the manufacturer. ACS, the ACS logo and ACS product names belong to Advanced Card Systems Ltd. Windows is a trademark of Microsoft Corporation.
