How to Read Write Data to RFID Tag: Complete Guide for UHF and HF

You have a stack of blank tags and a reader. Now what? Reading is one thing. Writing—actually putting your own data onto those tags—that is where things get real.

Here is the thing. When people search how to read write data to RFID tag, they usually discover that writing is not just the reverse of reading. Different tag types, different memory structures, passwords, lock bits. Get it wrong and you can lock yourself out of a tag forever.

Let me walk through what reading and writing actually means and how to do it without bricking your tags.

First: Understand Tag Memory Structure

Before you can read or write anything, you need to know how the tag organizes data.

For UHF RAIN RFID tags (ISO 18000-6C):

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 memory—size varies by tag type

When you do a standard inventory, you are reading Bank 01 (EPC). To read or write user memory, you target Bank 11.

For HF Mifare Classic tags (13.56 MHz):

Memory is organized into sectors and blocks :

• 16 sectors on a 1K card (numbered 0 to 15)
• Each sector has 4 blocks of 16 bytes
• Total: 64 blocks, 1024 bytes

The last block of each sector (block 3, 7, 11, etc.) is the “sector trailer” containing access keys. The first block of sector 0 (block 0) holds manufacturer data and is read-only .

Important: Different cards have different numbers of sectors and blocks. Mifare 4K has 40 sectors. Always check the tag datasheet .

Method 1: Read Write UHF Tags with CYKEO SDK

The CYKEO SDK handles the low-level commands so you focus on data.

Python example for UHF tag read/write:

python

from cykeo_sdk import UHFReader

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

# First, find a tag
def on_tag(tag):
    print(f"Found tag EPC: {tag.epc}")
    
    # ---- READ OPERATION ----
    # Read EPC bank (Bank 01)
    epc_data = reader.read_tag_memory(
        epc=tag.epc,
        memory_bank="EPC",     # or use 1
        offset=2,               # skip PC word
        length=6                # read 6 words (12 bytes)
    )
    print(f"EPC: {epc_data.hex()}")
    
    # Read user memory (Bank 11)
    user_data = reader.read_tag_memory(
        epc=tag.epc,
        memory_bank="USER",     # or use 3
        offset=0,               # start at word 0
        length=8                # read 8 words (16 bytes)
    )
    if user_data:
        print(f"User memory: {user_data.hex()}")
    
    # ---- WRITE OPERATION ----
    # Prepare data to write (16 bytes of ASCII)
    write_data = b"PROD-1234-5678  "
    
    # Write to user memory
    success = reader.write_tag_memory(
        epc=tag.epc,
        memory_bank="USER",
        offset=0,
        data=write_data
    )
    
    if success:
        print("Write successful")
        
        # Verify by reading back
        verify = reader.read_tag_memory(tag.epc, "USER", 0, 8)
        if verify == write_data:
            print("Verification passed")

reader.on_tag_read = on_tag
reader.start_inventory(timeout=5)

Key parameters explained :

• Offset: Start position in 16-bit words. For EPC bank, offset 2 skips the Protocol Control word
• Length: Number of 16-bit words to read/write
• Access password: Required if tag is password-protected (default often 00000000)

Method 2: Read Write HF Tags (Mifare) with MFRC522

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

Basic read/write example:

python

from mfrc522 import SimpleMFRC522

reader = SimpleMFRC522()

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

# ---- READ OPERATION ----
id, text = reader.read()
print(f"Card UID: {id}")
print(f"Stored text: {text}")

# ---- WRITE OPERATION ----
new_text = "CYKEO-ACCESS-001"
print(f"Writing: {new_text}")

id, written = reader.write(new_text)
print(f"Write complete. UID: {id}")

For more control over blocks and sectors :

python

from mfrc522 import MFRC522

reader = MFRC522()

# Wait for card
(status, TagType) = reader.Request(reader.PICC_REQIDL)
(status, uid) = reader.Anticoll()

if status == reader.MI_OK:
    print(f"UID: {uid}")
    
    # Select the tag
    reader.SelectTag(uid)
    
    # Authenticate using default key
    key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
    trailer_block = 11  # Sector 3 trailer
    status = reader.Authenticate(reader.PICC_AUTHENT1A, trailer_block, key, uid)
    
    if status == reader.MI_OK:
        # ---- READ BLOCKS ----
        block_nums = [8, 9, 10]  # Sector 2 data blocks
        data = []
        for block_num in block_nums:
            block_data = reader.ReadTag(block_num)
            if block_data:
                data += block_data
        
        if data:
            print("Read data:", ''.join(chr(i) for i in data))
        
        # ---- WRITE BLOCKS ----
        text = "PROD-12345"
        # Pad to fill multiple blocks (16 bytes per block)
        data = bytearray()
        data.extend(bytearray(text.ljust(len(block_nums) * 16).encode('ascii')))
        
        i = 0
        for block_num in block_nums:
            reader.WriteTag(block_num, data[(i*16):(i+1)*16])
            i += 1
        print("Write complete")
    
    # Always stop authentication
    reader.StopAuth()

Important: The first block of sector 0 (block 0) contains manufacturer data and is read-only. Trailer blocks (3,7,11,etc.) contain access keys—writing to them incorrectly can lock the sector permanently .

Method 3: Using CYKEO Configuration Software

Sometimes you don’t need to code. CYKEO Rfid Tag Manager handles read/write through a graphical interface.

Steps in CYKEO Tag Manager :

1. Connect reader and click “Inventory” to find tags
2. Select a tag from the list
3. Navigate to the memory bank tab you want (EPC, TID, USER)
4. For reading: Click “READ” to fetch current data
5. For writing:
   • Enter new data in hex or ASCII
   • Set offset and length if needed
   • Enter access password if required
   • Click “WRITE”
6. Verify by reading back

The software automatically handles the commands and shows raw hex data alongside ASCII interpretation.

Method 4: Read Write with Mobile Apps

CYKEO Scan App for Android and iOS supports full read/write operations :

• Connect to CK-B5L Bluetooth handheld or CK-B4L USB reader
• Tap “Inventory” to find tags
• Tap any tag to view memory banks
• Select “Write” to modify EPC or user memory
• Enter data in hex or ASCII
• Confirm write and verify

The app handles authentication and block/sector mapping automatically.

Understanding Authentication and Passwords

Many tags require authentication before writing .

For UHF tags:

• Access password (32 bits, stored in Reserved bank)
• Default is often 00000000
• Must be provided in write commands

python

# Write with password
reader.write_tag_memory(
    epc=tag.epc,
    memory_bank="USER",
    offset=0,
    data=write_data,
    access_password="12345678"  # hex string
)

For Mifare Classic :

• Each sector has Key A and Key B (6 bytes each)
• Default key is often FF FF FF FF FF FF
• Must authenticate to sector before reading/writing its blocks
• Different keys can have different permissions (read-only, read-write)

Locking and Permalock

After writing, you can lock memory to prevent changes :

• Locked: Cannot be overwritten, but can still be read
• Permalocked: Lock status is permanent—cannot be changed
• Read-protected: Some banks can be configured to block reads entirely

To lock user memory on UHF tags:

python

# Lock user memory (prevent future writes)
reader.lock_tag_memory(
    epc=tag.epc,
    memory_bank="USER",
    lock_type="LOCK"  # or "PERMALOCK"
)

Method 5: Raw Commands via Serial/TCP

If you’re working without an SDK, you can send ASCII commands directly .

For CYKEO readers:

text

# Inventory
#INV

# Read user memory (8 words starting at word 0)
#RD USER,0,8

# Write to user memory (data in hex)
#WR USER,0,8,A1B2C3D4E5F6A7B8

Connect via serial (COM port) or TCP (IP address + port 23) and send commands.

Real Example: Production Line Tag Encoding

Here is how a automotive parts supplier in Germany uses read/write:

The challenge: 10,000 engine parts per day need unique serial numbers and production data written at the assembly line.

The solution :

1. Blank tags arrive on pallets
2. At first station, CK-D8A embedded reader writes:
   • Part number to EPC bank
   • Unique serial number to user memory
   • Production date to user memory
3. At quality control, reader verifies data by reading back
4. Throughout production, readers update user memory with test results

Code snippet:

python

def encode_part(part_number, serial):
    # Wait for tag
    tag = reader.wait_for_tag(timeout=5)
    
    # Write part number to EPC (bank 1)
    epc_data = part_number.encode('ascii').ljust(12, b'\x00')
    reader.write_tag_memory(tag.epc, "EPC", 2, epc_data)
    
    # Write serial and date to user memory
    user_data = serial.encode('ascii').ljust(8, b'\x00')
    user_data += datetime.now().strftime("%Y%m%d").encode('ascii')
    reader.write_tag_memory(tag.epc, "USER", 0, user_data.ljust(16, b'\x00'))
    
    # Verify
    verify = reader.read_tag_memory(tag.epc, "USER", 0, 8)
    if verify == user_data.ljust(16, b'\x00'):
        print(f"Tag {tag.epc} encoded successfully")

Common Problems and Solutions

Problem: Write command returns error

• Tag may be locked or password-protected 
• Wrong memory bank specified
• Offset + length exceeds tag memory
• Tag too far from antenna

Problem: Can read but cannot write

• Tag may be permanently locked
• Access conditions restrict writing
• Wrong authentication key 

Problem: Data written but reads as garbage

• Wrong data format (hex vs ASCII mismatch)
• Wrong offset—data written to wrong location
• Endianness issues—some systems expect reversed byte order 

Problem: Mifare authentication fails

• Using wrong key 
• Trying to write to trailer block
• Card type not supported (Mifare DESFire requires different handling)

Problem: Writing works sometimes, fails others

• Tag moving during write—must stay stationary
• Interference from nearby metal
• Low battery in handheld reader

Write Verification Always

Always read back after writing to confirm :

python

# Write
reader.write_tag_memory(epc, "USER", 0, data)

# Verify
verify = reader.read_tag_memory(epc, "USER", 0, len(data)//2)
if verify == data:
    print("Write verified")
else:
    print("Write failed or data mismatch")

Tips for Success

1. Start with a test tag—never write to production tags until you verify your code works 
2. Know your tag specs—different tags have different memory sizes and structures
3. Handle authentication first—if a tag requires a password, provide it before read/write
4. Pad data appropriately—UHF writes are in 16-bit words; HF blocks are 16 bytes
5. Keep the tag stationary—moving during write can corrupt data
6. Document your data structure—what bytes mean what, so you can read it later
7. Test edge cases—what happens when data is too long? Too short? Wrong format?

The Bottom Line

How to read write data to RFID tag comes down to three things:

1. Understand your tag’s memory structure (banks for UHF, sectors for HF)
2. Authenticate if the tag is protected (passwords for UHF, keys for Mifare)
3. Target the right memory location with correct offset and length

Most failures happen because people treat all tags the same. A UHF tag is not a Mifare card. User memory is not EPC. Passwords matter.

Start with the CYKEO Tag Manager software to experiment safely. See what your tags can do. Then move to SDK for automation.

And when you get stuck—because everyone does—CYKEO support has seen every read/write problem there is. Call us with your tag type and what you are trying to do.

---

Need to program tags in your application?
CYKEO offers SDKs for Python, Java, C# with full read/write support for UHF and HF tags. Contact our team for developer samples and documentation.