How to Check PC/SC Reader Status and Reader Communication

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.

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:

LayerWhat it doesHow you check it
1. USB and driverWindows recognises the reader and loads a driverDevice Manager, Smart card readers: see checking whether Windows detects the reader and the driver installation guide
2. Smart Card serviceThe resource manager that every PC/SC program depends onsc query SCardSvr or Get-Service SCardSvr (below)
3. PC/SC reader list and statesThe readers the service offers to programs, and whether each holds a cardcertutil -scinfo, ACS QuickView or the C# check
4. Card communicationA program connects to the card and exchanges commandsATR shown, then a read-only command such as Get UID (below)

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.

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.

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.

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:

StateMeaningWhat it tells you
SCARD_STATE_EMPTYNo card in the readerReader and service work. Place a card to test further.
SCARD_STATE_PRESENTA 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_UNPOWEREDThe card is present but not powered upOften normal while no program is connected to the card.
SCARD_STATE_INUSEOne or more other programs are connected to the card, but it can still be sharedYour program can connect in shared mode. If it asks for exclusive access, it will fail.
SCARD_STATE_EXCLUSIVEAnother program has taken the card for its own exclusive useNothing else can connect until that program lets go. This is the usual cause of "another program is using the reader".
SCARD_STATE_MUTEThere is a card, but it does not respondCard not supported by this reader, damaged, or badly placed. Try another card of a type the reader supports.
SCARD_STATE_UNAVAILABLEThe reader's actual state is not availableUnplug and replug the reader; check Device Manager for a warning mark.
SCARD_STATE_UNKNOWNThe reader name is not recognised by the serviceThe 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.

  1. Close every card program you can see, including its icon in the notification area.
  2. Check Task Manager for a second copy of your own program.
  3. Run the status check again. The INUSE or EXCLUSIVE flag should be gone.
  4. 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.

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.

  1. 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.
  2. 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.
  3. 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 by 90 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.

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 valueMicrosoft's meaning (summarised)What it usually means in practice
SCARD_E_NO_SERVICE
0x8010001D
The smart card resource manager is not runningSmart Card service stopped or disabled. Start it (Check 1).
SCARD_E_SERVICE_STOPPED
0x8010001E
The resource manager has shut downThe service stopped or restarted while your program was using it. Release the context, then establish a new one.
SCARD_E_NO_READERS_AVAILABLE
0x8010002E
No smart card reader is availableService running, but no reader registered. Check the USB connection and driver, or Remote Desktop redirection.
SCARD_E_READER_UNAVAILABLE
0x80100017
The specified reader is not currently availableReader unplugged or reset while in use. Replug it and list the readers again.
SCARD_E_UNKNOWN_READER
0x80100009
The specified reader name is not recognisedYour program uses a stored or hard-coded name that no longer matches. Pick the reader from a fresh list.
SCARD_E_NO_SMARTCARD
0x8010000C
The operation needs a card, but none is in the deviceNo card on the reader when connecting. Place the card first, or wait for PRESENT before connecting.
SCARD_W_REMOVED_CARD
0x80100069
The card has been removed, so further communication is not possibleThe card left the field or slot during the exchange. Hold contactless cards flat and still.
SCARD_W_RESET_CARD
0x80100068
The card was resetAnother program reset the card while you were connected. Reconnect.
SCARD_W_UNRESPONSIVE_CARD
0x80100066
The card is not responding to a resetCard not supported, faulty, or upside down in a contact reader. Try a known good card.
SCARD_W_UNPOWERED_CARD
0x80100067
Power has been removed from the cardThe card lost power during the exchange. Reconnect; check the USB port and cable.
SCARD_E_SHARING_VIOLATION
0x8010000B
The card cannot be accessed because of other outstanding connectionsAnother program holds the card. See "Another program is using the reader".
SCARD_E_PROTO_MISMATCH
0x8010000F
The requested protocols are incompatible with the protocol in useRequest both T=0 and T=1 when connecting unless you know the card's protocol.
SCARD_E_NOT_READY
0x80100010
The reader or card is not ready to accept commandsWait a moment after the card arrives, then retry.
SCARD_E_TIMEOUT
0x8010000A
The user-specified time-out has expiredNormal when waiting for a card with SCardGetStatusChange and none arrived. Not a fault.
SCARD_F_COMM_ERROR
0x80100013
An internal communications error has been detectedCommunication with the reader failed. Replug the reader, try another USB port, check the driver.
SCARD_E_COMM_DATA_LOST
0x8010002F
A communications error with the card has been detectedCard moved or poor contact. Retry with the card held still or reinserted.
SCARD_E_INVALID_HANDLE
0x80100003
The supplied handle was not validYour code used a context or card handle after releasing it, or after the service restarted.
SCARD_E_INSUFFICIENT_BUFFER
0x80100008
The buffer for returned data is too smallAsk for the needed size first (as the C# check does for the reader list), then call again.
ERROR_BROKEN_PIPE
0x00000109
A smart card operation was attempted in a remote session on an operating system that does not support smart card redirectionRemote 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 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 -scinfo inside 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) from SCardEstablishContext means 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.

Work from the top: a problem higher in the table hides the ones under it.

What you seeLikely causeWhat to do
Reader missing from Device ManagerUSB, 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 0x8010001DSmart Card service stopped or disabledCheck 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 sessionReplug 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 itCard type not supported by this reader, or card badly placedUse 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 ATRCard does not answer the readerTry a second, known good card. For contact cards, insert chip first and face up.
State shows EXCLUSIVE, or connect returns 0x8010000BAnother program holds the cardClose other card software; see "Another program is using the reader".
Works in QuickView but not in your programCode issue: wrong reader name, wrong share mode or protocol, handles not releasedCompare with the read-only C# check above and the examples in the smart card SDK guide.
Works for a while, then 0x8010001E or 0x80100003Service restarted or reader replugged while your program held old handlesCatch these codes, release everything, establish a new context and list the readers again.

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.

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.

Reader found by Windows but not by your software?

Tell us the reader model, Windows version and the PC/SC error code you see. We help connect ACS readers to your application, locally or over Remote Desktop.