ACR1252U SDK and Developer Resources

Do you need the ACR1252U SDK to write software for the ACR1252U? No. The ACR1252U is a CCID reader with a standard PC/SC interface, so a Windows program can find it and read a card UID through winscard.dll with nothing more than the free ACS driver and the ACS API manual. The official ACR1252U SDK is a boxed developer kit from ACS: a reader, MIFARE, ACOS3 and ACOS6-SAM test cards, ACS tools and PC/SC sample code in Java, VB.NET, C# and C++. It is most useful when you plan to use the SAM slot or the NFC peer-to-peer and card emulation modes.

Below: what ACS puts in the kit, how PC/SC works with the ACR1252U's two reader interfaces, the reader-specific commands ACS documents (escape commands, SAM, NFC modes), and a short C# (.NET 8) program that detects the reader and reads a card UID. BSD Infotech is an independent ACS supplier and integrator in New Delhi, not the manufacturer. The SDK, drivers and manuals come from ACS; this page links to them and does not host copies.

ACS calls the kit the ACR1252U NFC Forum-Certified Reader Software Development Kit. Its contents, as listed on the official ACS ACR1252U SDK page (checked on 16 Nov 2026):

Part of the kitWhat ACS listsWhy a developer cares
Reader1 x ACR1252U NFC Forum-certified readerA reader to develop on, if you don't already have one.
Test cards5 x MIFARE Classic 1K, 5 x ACOS3 contactless smart cards, 1 x ACOS6-SAM secure access module cardThe ACOS3 cards and the ACOS6-SAM let you try SAM-based key diversification without buying a SAM separately.
Tools and utilitiesPC/SC Learning Tool, QuickView, Script Tool 5, Smart Card and Reader ToolThe Smart Card and Reader Tool includes NFC and NDEF tools that show peer-to-peer and card emulation working.
DocumentsReference manual(s)The command set for the reader and the cards.
Sample codeBasic card and reader commands in Java, Visual Basic .NET 2013, Visual C# .NET 2013 and Visual C++ .NET 2013PC/SC-based projects for reader (device) programming and contactless card programming.
SDK operating systemsWindows 7, Windows 8.1 and Windows 10Windows 11 is not in ACS's list for the kit. The reader itself has a current ACS PC/SC driver for Windows 10 and 11.

For availability and price in your country, ask BSD Infotech about the ACR1252U SDK kit.

What you can get free, without the kit

The ACS ACR1252U drivers and manuals page has the PC/SC drivers for Windows, Linux and macOS, the Android library, the technical specification and the Application Programming Interface manual for the ACR1252U (version 1.17 when we checked on 16 Nov 2026). QuickView, Script Tool and the Smart Card and Reader Tool are free on the ACS utility tools page. With those, a reader and a few cards you can build and test everything on this page. The kit adds the ACOS3 and ACOS6-SAM cards, the sample projects and the PC/SC Learning Tool.

Windows talks to smart card readers through the Smart Card service; programs reach it through winscard.dll. The ACR1252U connects over USB as a CCID device, and ACS's API manual describes two PC/SC reader interfaces inside it: the PICC interface for contactless cards and NFC, and the SAM interface for the card in the SAM slot. Each appears as its own entry in the PC/SC reader list. The manual's examples name the contactless entry "ACS ACR1252 1S CL Reader PICC 0" and say the name depends on the reader, so match on part of the name (for example "ACR1252" plus "PICC") rather than the whole string.

Install the ACS PC/SC driver before you start; the ACR1252U driver, software and test guide walks through it on Windows 10 and 11.

Card commands and reader commands use different calls

You want toWindows PC/SC callHow ACS documents it for the ACR1252U
Talk to the card (UID, MIFARE blocks, DESFire or ACOS3 APDUs)SCardTransmitConnect to the PICC interface while a card is present. APDUs for ISO 14443-4 cards pass through; commands starting FF are pseudo-APDUs the reader carries out itself.
Talk to the reader (firmware, LED, buzzer, polling, NFC modes)SCardControl"Escape" commands starting E0, sent with control code SCARD_CTL_CODE(3500), which ACS writes as 0x310000 + 3500 * 4. ACS's example connects in direct mode (SCARD_SHARE_DIRECT), so no card is needed.
Talk to the SAMSCardTransmitConnect to the SAM interface. To your program the SAM is an ordinary contact card (ISO 7816, T=0 or T=1).

The order of calls

  1. SCardEstablishContext opens a session with the Smart Card service. A non-zero result usually means the service is not running.
  2. SCardListReaders returns every reader name. Pick the ACR1252U PICC entry (or the SAM entry for SAM work).
  3. SCardConnect opens the reader. In shared mode this needs a card on the reader; in direct mode (escape commands) it does not.
  4. SCardTransmit or SCardControl sends the command. Card replies end with a status word; 90 00 is success. Escape replies start with E1.
  5. SCardDisconnect and SCardReleaseContext close everything, even after an error.

The same calls exist in pcsc-lite on Linux and macOS, so the logic carries over. For PC/SC, CCID and CT-API across all ACS readers, see the smart card and NFC reader SDK guide.

Reading a UID works the same way on most ACS contactless readers. These are the ACR1252U features in the ACS API manual (version 1.17) that change what your code does. BSD Infotech has not yet run these commands on hardware; they are summarised from the manual, not tested.

The SAM slot

The reader has one slot for an ISO 7816 Class A SAM (secure access module). ACS positions it for key diversification and mutual authentication, so the secret master keys stay inside the SAM instead of in your application. Your program opens the SAM interface and sends APDUs to the SAM, then uses the result with the contactless card on the PICC interface. The manual has a chapter of ACOS6-SAM commands, for example Generate Key (80 88), which derives a card-specific key from data such as the card's serial number when issuing ACOS3 or ACOS6 cards. ACS says the complete ACOS6-SAM reference manual is available from an ACS representative. If your scheme uses a different SAM, its commands come from that SAM's supplier.

Three NFC modes

  • Card reader/writer is the normal mode and the one PC/SC programs expect.
  • Peer-to-peer lets the reader exchange data with a phone or another NFC device, in initiator or target role. The manual has escape commands for each step of the exchange (enter initiator or target mode, timeouts, data exchange, release) and an appendix on SNEP messages.
  • Card emulation makes the reader behave like a MIFARE Ultralight or FeliCa card towards a phone or another reader. It is entered with the escape command E0 00 00 40 03 <mode> 00 00: mode 01 = MIFARE Ultralight emulation, 03 = FeliCa emulation, 06 = peer-to-peer initiator, and the manual treats any other value as card read/write mode. The emulated Ultralight UID can be set, and its lock bytes are not supported.

Switching mode changes how the reader behaves for every program on the PC. If your normal PC/SC code suddenly stops seeing cards, check that nothing left the reader in emulation or peer-to-peer mode.

Moving code over from the ACR122U

The manual has a section of ACR122U-compatible commands: the FF 00 40 LED and buzzer command, FF 00 48 00 00 for the firmware version, and get/set PICC operating parameter. The MIFARE Classic pseudo-APDUs (FF 82, FF 86, FF B0, FF D6) and Get Data (FF CA) have the same layout as on the ACR122U. So most ACR122U code needs only a new reader name, but test it, because firmware behaviour can differ. Our ACR122U SDK and developer guide covers that reader.

Commands documented by ACS for the ACR1252U

Hexadecimal, from the ACS ACR1252U API manual v1.17. Only read-only commands and the commands you need for MIFARE Classic are listed; look up everything else in the manual before using it.

TaskCallCommandNotes from the manual
Card UID (Get Data)SCardTransmitFF CA 00 00 00UID followed by 90 00. 63 00 = failed, 6A 81 = not supported.
ATS of an ISO 14443-4 Type A cardSCardTransmitFF CA 01 00 00Also helps tell ISO 14443-4 Type A from Type B cards.
ATQA + UID + SAK (Type A) or ATQB (Type B)SCardTransmitFF CA 00 02 00Firmware 110.0 or later only.
Load a MIFARE Classic keySCardTransmitFF 82 00 <loc> 06 <6-byte key>Locations 00 and 01 are volatile and cleared when the reader is unplugged.
Authenticate a MIFARE Classic blockSCardTransmitFF 86 00 00 05 01 00 <block> <type> <loc>Type 60 = key A, 61 = key B. One success opens the whole sector.
Read MIFARE Classic dataSCardTransmitFF B0 00 <block> <length>The block must be authenticated first.
Reader firmware versionSCardControlE0 00 00 18 00Reply E1 00 00 00 <len> then ASCII text; the manual's example is "ACR1252U_V100.1".
Read the LED stateSCardControlE0 00 00 29 00Bit 0 = red, bit 1 = green.
Read the PICC typeSCardControlE0 00 00 35 00Card type and status, e.g. CC = no card, 10 = MIFARE. Firmware 110.0 or later only.

Careful with writes. The manual also documents writing MIFARE blocks (FF D6), value-block operations, LED and buzzer control, automatic polling and operating-parameter settings, and serial-number commands. Some settings stay in the reader, and on MIFARE Classic a wrong write to a sector trailer can lock the sector for good. Try them on a spare reader and spare cards first.

Language: C# 12 on .NET 8, Windows only (P/Invoke to winscard.dll; no NuGet packages). Prerequisites: Windows 10 or 11, the .NET 8 SDK, the ACR1252U connected with the ACS PC/SC driver installed, and a card on the reader (for example MIFARE Classic 1K or NTAG). Run dotnet new console, replace Program.cs with the code below, then dotnet run. The program only reads: it lists the readers, picks the ACR1252U contactless interface and sends Get Data (FF CA 00 00 00). It writes nothing to the card or the reader.

Not yet tested on hardware. Written against the Windows PC/SC API and the Get Data command in the ACS ACR1252U API manual. BSD Infotech has compiled it and run it on a PC without an ACR1252U (it correctly reported "No ACR1252U found"), but has not yet run it with an ACR1252U and a card. Treat it as a starting point.

// C# 12, .NET 8, Windows only (winscard.dll). Not yet tested on hardware.
using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

const uint SCARD_SCOPE_USER = 0, SCARD_SHARE_SHARED = 2, SCARD_PROTOCOL_T0 = 1,
           SCARD_PROTOCOL_T1 = 2, SCARD_LEAVE_CARD = 0;
const int SCARD_E_NO_SMARTCARD = unchecked((int)0x8010000C),
          SCARD_W_REMOVED_CARD = unchecked((int)0x80100069),
          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($"Smart Card service not available: 0x{rc:X8}"); return; }
try
{
    // 1. Detect: list every PC/SC reader, keep the ACR1252U entries.
    string[] all = ListReaders(ctx);
    string[] acr1252 = all.Where(r => r.Contains("ACR1252", StringComparison.OrdinalIgnoreCase)).ToArray();
    if (acr1252.Length == 0)
    {
        Console.WriteLine("No ACR1252U found. Readers seen: " + (all.Length == 0 ? "none" : string.Join(" | ", all)));
        return;
    }
    foreach (string r in acr1252) Console.WriteLine("Found: " + r);

    // 2. Use the contactless (PICC) interface, not the SAM slot.
    string? picc = acr1252.FirstOrDefault(r => r.Contains("PICC", StringComparison.OrdinalIgnoreCase));
    if (picc is null) { Console.WriteLine("No PICC interface in the list above. Check the driver."); return; }

    // 3. Connect. This only succeeds while a card is on the reader.
    rc = WinScard.SCardConnect(ctx, picc, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
                               out IntPtr card, out uint protocol);
    if (rc == SCARD_E_NO_SMARTCARD || rc == SCARD_W_REMOVED_CARD)
    { Console.WriteLine("No card on the reader. Place a card and run again."); return; }
    if (rc != 0) { Console.WriteLine($"SCardConnect failed: 0x{rc:X8}"); return; }

    try
    {
        // 4. Get Data (UID): FF CA 00 00 00 -> UID bytes + 90 00
        byte[] resp = Transmit(card, protocol, [0xFF, 0xCA, 0x00, 0x00, 0x00]);
        if (resp.Length > 2 && resp[^2] == 0x90 && resp[^1] == 0x00)
            Console.WriteLine("UID: " + Convert.ToHexString(resp, 0, resp.Length - 2));
        else
            Console.WriteLine("Get Data did not succeed. Status word: " + Convert.ToHexString(resp));
    }
    finally { WinScard.SCardDisconnect(card, SCARD_LEAVE_CARD); }
}
finally { WinScard.SCardReleaseContext(ctx); }

static string[] ListReaders(IntPtr ctx)
{
    uint chars = 0;
    int rc = WinScard.SCardListReaders(ctx, null, null, ref chars);
    if (rc == SCARD_E_NO_READERS_AVAILABLE) return [];
    if (rc != 0) throw new InvalidOperationException($"SCardListReaders failed: 0x{rc:X8}");
    var buf = new char[chars];
    rc = WinScard.SCardListReaders(ctx, null, buf, ref chars);
    if (rc != 0) throw new InvalidOperationException($"SCardListReaders failed: 0x{rc:X8}");
    return new string(buf, 0, (int)chars).Split('\0', StringSplitOptions.RemoveEmptyEntries);
}

static byte[] Transmit(IntPtr card, uint protocol, byte[] apdu)
{
    var pci = new WinScard.SCARD_IO_REQUEST { dwProtocol = protocol, cbPciLength = (uint)Marshal.SizeOf<WinScard.SCARD_IO_REQUEST>() };
    var recv = new byte[258];
    uint len = (uint)recv.Length;
    int rc = WinScard.SCardTransmit(card, ref pci, apdu, (uint)apdu.Length, IntPtr.Zero, recv, ref len);
    if (rc != 0) throw new InvalidOperationException($"SCardTransmit failed: 0x{rc:X8}");
    return recv[..(int)len];
}

static class WinScard
{
    [StructLayout(LayoutKind.Sequential)]
    public struct SCARD_IO_REQUEST { public uint dwProtocol; public uint cbPciLength; }

    [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 = "SCardConnectW", CharSet = CharSet.Unicode)]
    public static extern int SCardConnect(IntPtr context, string reader, uint shareMode, uint preferredProtocols,
                                          out IntPtr card, out uint activeProtocol);

    [DllImport("winscard.dll")]
    public static extern int SCardDisconnect(IntPtr card, uint disposition);

    [DllImport("winscard.dll")]
    public static extern int SCardTransmit(IntPtr card, ref SCARD_IO_REQUEST sendPci, byte[] sendBuffer, uint sendLength,
                                           IntPtr recvPci, byte[] recvBuffer, ref uint recvLength);
}

Expected result with a card on the reader: one "Found:" line for each ACR1252U interface (the contactless PICC entry, and normally a second entry for the SAM slot), then a line such as UID: 04A1B2C3D4E5F6. A MIFARE Classic 1K card usually has a 4-byte UID and an NTAG a 7-byte UID. Bytes are printed in the order the reader returns them.

If it fails: "No ACR1252U found" means Windows does not list the reader: check Device Manager and the driver. "No card on the reader" comes from SCardConnect returning 0x8010000C or 0x80100069. 0x8010000B (sharing violation) means another program, such as QuickView, holds the reader; close it. A status word of 6A 81 means the command is not supported for that card, and 63 00 means the reader could not finish it, often because the card moved.

Next steps from here

To read the firmware version, open the PICC interface with SCARD_SHARE_DIRECT and send E0 00 00 18 00 through SCardControl with control code 0x310000 + 3500 * 4, as in the ACS manual. For a long-running program, use SCardGetStatusChange to wait for a card instead of connecting in a loop.

When your program fails, find out first whether the reader, the driver or your code is at fault. If a ready-made tool can read the card and your program can't, the problem is in your code. The ACS reader testing and utilities centre compares the free ACS tools and the BSD utilities, and the ACR1252U driver and test guide has the checks in order. For specifications, the SAM slot and price, see the ACR1252U NFC reader page.

What you seeLikely causeWhat to do
The ACR1252U is not in the reader listDriver not installed, Smart Card service stopped, or a USB problemCheck Device Manager (Smart card readers) and the Smart Card service, then follow the driver guide.
Your program picks the wrong ACR1252U entryThe reader has two interfaces: PICC (contactless) and SAMSelect by name: "PICC" for cards, the SAM entry for the SAM. Never use a fixed index.
SCardConnect returns 0x8010000CNo card on the reader (shared mode needs one)Place a card first, or wait for one with SCardGetStatusChange. For reader-only commands, connect in direct mode.
SCardConnect returns 0x8010000BAnother program has the reader open exclusivelyClose QuickView, Script Tool or other card software and try again.
SCardControl fails for an E0 commandWrong control code, wrong share mode, or a driver that does not pass escape commandsUse SCARD_CTL_CODE(3500) (0x310000 + 3500 * 4) on the PICC entry, connect with SCARD_SHARE_DIRECT, and use the ACS PC/SC driver.
Get Data returns 6A 81Command not supported for this card or modeCheck the card type and that the reader is in card read/write mode, not card emulation or peer-to-peer.
MIFARE read returns 63 00Authentication missing or the wrong keyLoad the key (FF 82), authenticate the block (FF 86), then read. Factory keys are often FF FF FF FF FF FF, but not always.
Phones or other readers see an unexpected tagThe reader was left in card emulation modeReturn it to card read/write mode (see the NFC modes section above).

Kit contents, reader features and commands were checked on the official ACS pages and manual on 16 Nov 2026:

This page is BSD Infotech's own explanation, not ACS text. 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. MIFARE, FeliCa and other names are trademarks of their owners.

Building software for the ACR1252U?

Tell us what the reader needs to do in your application. BSD Infotech can supply the readers and cards, and write the integration or the complete software.