How to Read RFID Cards: UID, User Data, and What Actually Comes Out

You hold an RFID card to a reader. Beep. Something happened. But what did you actually get? A number? A name? Access granted or denied?

Here is the thing most people miss when they search how to read RFID cards. There is reading, and then there is reading. Some cards just spit out a serial number. Others hold paragraphs of data. And the reader you use determines which one you get.

Let me walk through what “reading a card” actually means and how to do it without losing your mind.

First: What Kind of Card Are You Holding?

Before you can read anything, you need to know what you are dealing with. RFID cards come in two main flavors :

Low Frequency (125 kHz): Old school proximity cards. HID Prox, Indala, most older access control cards. These things only store a number. That is it. You cannot write to them, you cannot store your name on them. They just broadcast a fixed ID when awakened .

High Frequency (13.56 MHz): Smarter cards. Mifare Classic, DESFire, NFC tags. These have real memory—sectors, blocks, the works. A standard Mifare 1K card has 16 sectors, each with 4 blocks, total 1024 bytes of storage . You can read the UID, sure, but you can also read actual data stored on the card.

Ultra High Frequency (860-960 MHz): RAIN RFID cards and tags. Longer range, used in logistics and vehicle access. These also store data but organized differently .

If you grabbed a random card from 2005, it is probably 125 kHz and only gives you a number. If it is a modern office badge, likely 13.56 MHz with actual data .

Method 1: Reading Just the Card UID (The Simple Way)

For access control, you usually only need the card’s unique ID. The UID. This is the number the door controller checks against its database .

Using a desktop USB reader:

Most desktop RFID readers act like keyboards. You hold the card up, and the UID gets typed into whatever field has focus .

CYKEO CK-D1L desktop encoder works this way. Plug it in via USB, open Notepad, tap a card. The UID appears as a string of hex digits . No software needed for basic reads.

Using an access control panel:

If you are adding cards to a door system, you typically present the card to the reader while the panel is in programming mode. The panel captures the UID and stores it .

For 2N intercoms, you go to the web interface, find Events, present the card, and copy the “uid” parameter . Then paste it into the user record.

Using an Android phone with NFC:

If your phone has NFC, you can read 13.56 MHz cards without any extra hardware. Apps like “NFC Tools” show you the UID and tag type instantly . Works for Mifare, NTAG, DESFire.

But here is the catch: phones only read HF/NFC. They cannot read 125 kHz proximity cards or UHF RAIN cards . For those, you need external readers.

Method 2: Reading Card Data (The Real Way)

When you need more than just an ID—like name, expiry date, or custom data—you have to read the card’s memory.

Card memory structure (Mifare Classic example):

Mifare 1K cards organize memory into sectors and blocks :

• 16 sectors, numbered 0 to 15
• Each sector has 4 blocks
• Each block holds 16 bytes
• Total: 64 blocks, 1024 bytes

Important restrictions :

• Block 0 (first block of sector 0) stores manufacturer data—read only
• The last block of each sector (block 3, 7, 11, etc.) is the “trailer block” containing access keys
• Writing to trailer blocks can lock you out permanently

Reading with Python and MFRC522:

For hobby projects with Raspberry Pi, the MFRC522 module is standard .

First, install the library:

bash

pip install mfrc522-python

Basic read example :

python

from mfrc522 import MFRC522

reader = MFRC522()

print("Hold card near reader...")

# Wait for card
while True:
    (status, TagType) = reader.Request(reader.PICC_REQIDL)
    if status == reader.MI_OK:
        break

# Get UID
(status, uid) = reader.Anticoll()
if status == reader.MI_OK:
    print("Card UID:", uid)
    
    # Select card for further operations
    reader.SelectTag(uid)
    
    # Authenticate using default key
    key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
    status = reader.Authenticate(reader.PICC_AUTHENT1A, 8, key, uid)
    
    if status == reader.MI_OK:
        # Read block 8 (first block of sector 2)
        data = reader.ReadTag(8)
        if data:
            print("Data block 8:", data)
    
    # Always stop authentication when done
    reader.StopAuth()

The SimpleMFRC522 class makes it even easier :

python

from mfrc522 import SimpleMFRC522

reader = SimpleMFRC522()
id, text = reader.read()
print(f"Card ID: {id}")
print(f"Stored text: {text}")

Reading with Raspberry Pi Pico (MicroPython):

For embedded projects, there is a MicroPython module for MFRC522 . Same basic flow: request card, anti-collision, select, authenticate, read.

The Pico example reads the UID, then compares it against a hardcoded value. If match, green LED flashes; if not, red LED . Good model for access control experiments.

Method 3: Reading with CYKEO Professional Readers

For production systems, you want something that just works. CYKEO desktop encoders and handhelds handle the complexity so you do not have to .

CYKEO CK-D1L Desktop Encoder:

This is a Type-C connected UHF desktop reader for RAIN RFID cards . It reads at 840-960 MHz, covers all major regions. The neat part: near-field antenna limits reading to about 30cm, so you do not accidentally read every card on the desk .

In your application, you use the CYKEO SDK:

python

from cykeo_sdk import DesktopEncoder

encoder = DesktopEncoder("COM3")  # or USB auto-detect
encoder.connect()

def on_card_read(card):
    print(f"Card UID: {card.epc}")
    print(f"TID: {card.tid}")  # factory-programmed unique ID
    print(f"User memory: {card.user_data}")

encoder.on_card = on_card_read
encoder.start_reading()

CYKEO CK-B5L Handheld Reader:

For mobile reading, the CK-B5L connects via Bluetooth to Android or iOS devices . It reads UHF tags up to 8 meters away—good for inventory where you cannot touch every item.

The SDK handles the Bluetooth connection, tag filtering, and data formatting so you focus on the app logic .

Method 4: Reading with Configuration Tools

Sometimes you do not need to code. You just want to see what is on a card or configure a reader to work with your cards.

rf IDEAS Configuration Utility:

This Windows tool connects to compatible readers and includes a “Card Analyzer” . You place a card on the reader, click “Learn Card,” and the utility tries every standard until it finds one that works. Then it shows you what data it can read and lets you configure the reader accordingly .

Useful when you inherit a box of mystery cards and need to figure out what they are.

What Data Can You Actually Read?

This depends on the card type and access permissions .

125 kHz proximity cards: Just the UID. Usually 24-32 bits, often printed on the card as decimal or hex. No user memory .

Mifare Classic 1K/4K:

• UID (4 or 7 bytes)
• Manufacturer data (block 0, read only)
• User data in blocks 1-63 (except trailer blocks)
• Sector trailers containing access keys (readable if you know the key)

Mifare DESFire: More complex file system. Can store multiple applications with encrypted files. Requires more advanced readers and authentication.

UHF RAIN RFID cards:

• EPC (Electronic Product Code) – main identifier
• TID (Tag Identifier) – factory programmed, unique
• User memory (size varies by tag)

Authentication: The Key to Reading Locked Cards

Here is where people get stuck. Many cards require authentication before they let you read user data .

Mifare Classic uses a simple challenge-response with 6-byte keys. Each sector can have its own key. The default key for many cards is all 0xFF :

python

default_key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

If the card uses a different key, you need to know it. For access control systems, the facility code and site code are often used to derive keys.

The authentication step happens after selecting the card but before reading any blocks . If authentication fails, you get nothing.

Common Problems When Reading Cards

Problem: Reader sees card but no data comes back

Card might be locked or using unknown key. Try reading just the UID first—that usually works without authentication. If UID works but data does not, authentication is the issue.

Problem: Same card shows different UIDs on different readers

Some readers format UID differently. Decimal vs hex. Reversed byte order. Check the reader settings for consistent output format.

Problem: Can read some cards but not others

Different card types. Your reader might support Mifare but not DESFire, or 125 kHz but not 13.56 MHz. Check the reader specs.

Problem: Data reads as garbage

You might be reading the wrong block, or the block contains binary data that looks like garbage when printed as ASCII. Try reading as hex to see raw bytes.

Problem: Card reads once then stops

You forgot to stop authentication before reading another card. The MFRC522 requires StopAuth() between different cards . In the CYKEO SDK, this is handled automatically.

The Bottom Line

How to read RFID cards has three answers depending on what you need:

• Just the card number: Use a USB desktop reader, open Notepad, tap card. Done.
• Data stored on the card: Use an SDK (MFRC522 for hobby, CYKEO SDK for production). Handle authentication, read specific blocks, parse the data.
• Identify unknown cards: Use a configuration utility with “learn card” feature to detect type and readable data.

Most people overcomplicate it. If you only need access control, the UID is enough. If you need data off the card, you need to understand sectors, blocks, and keys.

And when you get stuck—because everyone does—CYKEO support has seen every card type there is. Call us with your reader model and what you are trying to read. We will walk you through it.

---

Need to read cards in your application?
CYKEO offers desktop encoders, Bluetooth handhelds, and fixed readers for every card type. SDKs for Python, Java, C# included. Contact our team for developer samples.