How to Read RFID Tag: From Basic UID to Advanced Data Access

You hold a tag near a reader. Beep. Something happened. But what did you actually get? Just a number? Or is there more data hiding on that tag?

Here is the thing. When people search how to read RFID tag, they usually mean one of two things. Either they want the tag’s unique ID—the thing that identifies it—or they want the actual data stored on the tag. These are different problems with different solutions.

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

First: What Kind of Tag Are You Reading?

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

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

High Frequency (13.56 MHz): Smarter tags. Mifare Classic, DESFire, NFC tags. These have real memory—sectors, blocks, the works. A standard Mifare 1K tag 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 tag.

Ultra High Frequency (860-960 MHz): RAIN RFID tags. Longer range, used in logistics and inventory. These also store data but organized differently—EPC, TID, User memory.

If you grabbed a random tag from 2005, it is probably 125 kHz and only gives you a number. If it is a modern inventory tag, likely UHF with multiple memory banks.

Method 1: Reading Just the Tag ID (The Simple Way)

For inventory and basic tracking, you usually only need the tag’s unique identifier. For UHF tags, this is the EPC (Electronic Product Code) . For HF tags, it is the UID.

Using a CYKEO CK-B4L USB reader:

This little device plugs into your phone or computer via USB-C. No batteries, no pairing :

• Plug the CK-B4L into your Android device or computer
• Open the CYKEO Scan app
• Hold a tag within 30cm of the reader
• The EPC appears on screen instantly

The CK-B4L uses near-field antenna technology so it only reads tags close by—no accidentally grabbing tags three aisles over .

Using a CYKEO CK-B5L Bluetooth handheld:

For walking around a warehouse, you want the CK-B5L :

• Power on the CK-B5L
• Pair via Bluetooth to your tablet or phone
• Open CYKEO Inventory app
• Pull the trigger and walk
• Tags up to 8 meters away appear on screen 

The CK-B5L can read 500+ tags in under 3 seconds . Good for cycle counting.

Using a fixed reader like CYKEO RA412:

For portal gates and conveyor belts:

• Reader is always on, connected via Ethernet
• Your software connects to the reader’s IP address
• Tags are streamed continuously as they pass

Method 2: Understanding Tag Memory Structure

Before you can read more than just the ID, you need to understand how tags store data.

UHF RAIN RFID tags have four memory banks :

Bank	Name	What It Stores
00	Reserved	Kill password and access password
01	EPC	Electronic Product Code—main identifier
10	TID	Tag Identifier—factory programmed, unique per tag
11	User	User data—size varies by tag type

When you do a standard inventory, you are reading Bank 01 (EPC). To get the TID or user memory, you need to issue different commands.

HF Mifare tags have sectors and blocks:

• 16 sectors on a 1K card
• Each sector has 4 blocks of 16 bytes
• Last block of each sector is the “trailer” containing access keys

Method 3: Reading Tag Memory with SDK

For production systems, you want control over which memory bank you read.

CYKEO Python SDK example:

python

from cykeo_sdk import UHFReader

# Connect to reader
reader = UHFReader("192.168.1.100")
reader.connect()

# Start inventory - this gets EPCs
def on_tag(tag):
    print(f"EPC: {tag.epc}")
    
    # Now read TID from that tag
    tid = reader.read_tag_memory(tag.epc, memory_bank="TID")
    print(f"TID: {tid.hex()}")
    
    # Read user memory if available
    user_data = reader.read_tag_memory(tag.epc, memory_bank="USER", offset=0, length=32)
    if user_data:
        print(f"User data: {user_data.hex()}")

reader.on_tag_read = on_tag
reader.start_inventory()

CYKEO Android SDK example :

java

// Initialize reader
UHFReader reader = new UHFReader(context);
reader.connect();

// Set tag listener
reader.setTagReadListener(new TagReadListener() {
    @Override
    public void onTagRead(TagRead tag) {
        String epc = tag.getEpc();
        
        // Read TID from this tag
        byte[] tid = reader.readTagMemory(epc, MemoryBank.TID, 0, 12);
        
        // Update UI
        runOnUiThread(() -> {
            textView.setText("EPC: " + epc + "\nTID: " + bytesToHex(tid));
        });
    }
});

reader.startInventory();

Method 4: Reading HF Tags (Mifare/NFC)

HF tags work differently. They require authentication before you can read data.

Using CYKEO HF desktop encoder:

python

from cykeo_sdk import HFReader

reader = HFReader("COM3")
reader.connect()

# Wait for card
def on_card(card):
    print(f"UID: {card.uid.hex()}")
    
    # Authenticate to sector 1 using default key
    if card.authenticate(sector=1, key_type="A", key="FFFFFFFFFFFF"):
        # Read block 4 (first block of sector 1)
        data = card.read_block(4)
        print(f"Block 4 data: {data.hex()}")
        
        # If data is ASCII text
        text = ''.join(chr(b) for b in data if 32 < b < 127)
        print(f"Text: {text}")

reader.on_card = on_card
reader.start_reading()

Method 5: Reading with Mobile Apps (No Coding)

Sometimes you just want to see what is on a tag without writing code.

CYKEO Scan App for Android/iOS :

• Download from app store
• Connect to your CYKEO reader via Bluetooth
• Tap “Inventory” to see all tags
• Tap any tag to see detailed memory banks
• Export data as CSV or share via email

The app handles all the authentication and memory bank selection automatically.

Method 6: Reading Multiple Tags Simultaneously

Real-world applications rarely read one tag at a time. Pallets have 50 cases. Shelves have hundreds of items.

CYKEO anti-collision handles this automatically. The reader talks to tags one at a time using a protocol that prevents collisions . The CK-B5L reads 500+ tags in 3 seconds .

For dense populations:

• Use higher power to energize all tags
• Set Q value appropriately (this controls how many tags respond at once)
• Filter duplicates in software

python

# CYKEO SDK handles anti-collision automatically
reader.start_inventory(duration=5)  # Read for 5 seconds

# After reading, you get unique tags
unique_tags = reader.get_unique_tags()
print(f"Found {len(unique_tags)} unique tags")

Method 7: Reading Tag Location (Phase and RSSI)

Modern readers can tell you more than just “tag is here.” They can tell you roughly where.

RSSI (Received Signal Strength): Stronger signal = tag closer. Not precise but useful for zoning.

Phase: The reader measures the phase of the returning signal. As a tag moves, phase changes. By comparing phase across multiple antennas, you can determine direction .

CYKEO readers expose both RSSI and phase in the tag read event:

python

def on_tag(tag):
    print(f"EPC: {tag.epc}")
    print(f"Antenna: {tag.antenna}")
    print(f"RSSI: {tag.rssi} dBm")
    print(f"Phase: {tag.phase} degrees")

Common Problems When Reading Tags

Problem: Reader sees no tags

• Check antenna connection. Loose cable kills reads.
• Is tag type compatible with reader frequency? US tags (902-928) won’t work well on European readers (865-868).
• Try different tag orientation. UHF tags are directional.
• Move tag closer. Start at 30cm and work outward.

Problem: Some tags read, some don’t

• Tags on metal need special on-metal tags.
• Tags near liquid (water bottles) absorb signal.
• Multiple tags too close together can cause collisions.
• Damaged tags—bent antennas, cracked chips.

Problem: Reads same tag over and over

Normal. Readers report tags continuously while in field. Filter duplicates in software:

python

# Simple deduplication
seen_tags = set()

def on_tag(tag):
    if tag.epc not in seen_tags:
        seen_tags.add(tag.epc)
        process_new_tag(tag)

Problem: Can read EPC but not user memory

• Tag may not have user memory (some cheap tags don’t)
• User memory may be locked
• You need to issue specific read command—not all apps do this

Problem: HF card authenticates but reads garbage

Wrong authentication key. You need the correct key for that sector. Default keys often work for development, but production cards use custom keys .

Reading Modes: Continuous vs Triggered

Most readers support different operating modes :

Continuous mode: Reader constantly queries for tags. Good for portals and conveyor belts.

Triggered mode: Reads only when you pull a trigger or external sensor activates. Good for handhelds.

Single mode: Reads one tag, then stops. Good for point-and-shoot applications.

On CYKEO handhelds, you can configure trigger behavior :

• Alternate: Press to start, press again to stop
• Once: Read one tag per trigger pull
• Continues: Hold trigger to keep reading, release to stop

The Bottom Line

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

• Just the ID: Use any reader with demo software. Hold tag near, read EPC/UID.
• Data from memory: Use SDK, authenticate if needed, read specific memory banks.
• Multiple tags fast: Use anti-collision, filter duplicates, process in batches.

Most people overcomplicate it. Start with the demo app that came with your CYKEO reader. See what data comes off your tags. Then move to SDK if you need more control.

And when you get stuck—because everyone does—CYKEO support has seen every tag 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 tags in your application?
CYKEO offers USB desktop readers, Bluetooth handhelds, and fixed readers for every tag type. SDKs for Python, Java, C# included. Contact our team for developer samples.