Sensors/ NFC/ RDM6300

RDM6300 RFID Reader Module

The RDM6300 is a simple and reliable 125kHz RFID reader module suitable for a wide range of identification and access control applications. Its straightforward UART interface ensures easy integration into any project requiring RFID capabilities.

RDM6300 RFID Reader Module image
RDM6300 · UART
UART
Interface
4pins
Connections
-10 to +70 °C
Operating temp
125kHz
Frequency
$4.00
Typical price
On this page

RDM6300 pinout

4 pins · UART

The RDM6300 has 4 pins: VCC, GND, TX (for data output), and RX (rarely used).

View:
RDM6300 RFID Reader Module pinout
PinTypeDescriptionNotes
VCCPowerPower supply input (3.3V to 5V). Flexible voltage range.Both 3.3V and 5V compatible.
GNDPowerGround connection. Connect to system ground.
TXUARTUART transmit data. Sends 125kHz RFID tag UID to microcontroller.Connect to ESP32 RX pin. Main data output.
RXUARTUART receive data. Bidirectional communication (rarely used).Optional - most applications only use TX.
  • 125kHz low-frequency RFID reader

  • Compatible with EM4100 protocol tags

  • UART output at 9600 baud (default)

  • Reading distance: typically 3-8cm

  • Automatic tag detection - no polling required

  • Outputs unique tag ID when card detected

Wiring the RDM6300 to ESP32

4 connections · 1 optional

To interface the RDM6300 with an ESP32, connect VCC to 3.3V or 5V, GND to ground, and TX to an ESP32 RX pin (GPIO 16) to receive tag UID data.

RDM6300 RFID Reader Module wiring with ESP32
RDM6300 pinESP32 pinPurpose
VCC3.3V or 5VPower supply. Use 3.3V or 5V depending on your setup.
GNDGNDGround connection.
TXGPIO 16 (RX2)Reader transmits tag UID to ESP32.
RXOptional GPIO 17Bidirectional communication (rarely needed). · optional
  • UART baud rate: 9600 bps (default, can be changed on some modules)

  • Use UART2 on ESP32 (GPIO 16/17) for hardware serial

  • Data format: 14-byte ASCII string containing tag UID

  • Automatic tag detection - continuously outputs when tag present

  • Reading distance: 3-8cm depending on tag size

  • Compatible tags: EM4100, EM4102, and similar 125kHz cards/tags

  • RX pin usually not needed - reader operates in output-only mode

  • Module includes coil antenna - ensure proper orientation

  • For access control: store authorized UIDs and compare readings

RDM6300 code examples

5 platforms
Platform:

RDM6300 Arduino example

Copy
// The RDM6300 sends each tag as a 14-byte ASCII frame over UART (9600 baud):
// STX(0x02) + 10 hex chars (2 version + 8 tag ID) + 2 checksum chars + ETX(0x03)

HardwareSerial rfid(2); // UART2: reader TX -> GPIO16 (RX2); TX to the reader is not needed

void setup() {
    Serial.begin(115200);
    rfid.begin(9600, SERIAL_8N1, 16, -1); // RX only
    Serial.println("RDM6300 initialized. Waiting for RFID tags...");
}

void loop() {
    if (rfid.available() && rfid.read() == 0x02) { // frame start
        char frame[13];
        int got = rfid.readBytes(frame, 13); // 10 data + 2 checksum + ETX
        if (got == 13 && frame[12] == 0x03) {
            char tagHex[9];
            memcpy(tagHex, frame + 2, 8); // skip the 2 version chars
            tagHex[8] = '\0';
            unsigned long tagId = strtoul(tagHex, NULL, 16);

            Serial.print("Tag detected: ");
            Serial.print(tagHex);
            Serial.print(" (decimal ");
            Serial.print(tagId);
            Serial.println(")");
        }
    }
    delay(50);
}

The RDM6300 only transmits, so a single UART connection is enough: reader TX to GPIO16 (UART2 RX). Each detected tag arrives as a 14-byte ASCII frame - start byte 0x02, ten hex characters (two version + eight tag ID), two checksum characters and end byte 0x03. The sketch syncs on the start byte, extracts the 8-character tag ID and prints it both as hex and as the decimal number often printed on the key fob.

RDM6300 ESP-IDF example

Copy
// The RDM6300 sends each tag as a 14-byte ASCII frame over UART (9600 baud):
// STX(0x02) + 10 hex chars (2 version + 8 tag ID) + 2 checksum chars + ETX(0x03)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"

#define RX_PIN 16 // Reader TX -> GPIO16; TX to the reader is not needed
#define UART_PORT UART_NUM_1

void init_uart(void) {
    uart_config_t uart_config = {
        .baud_rate = 9600,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
    };
    uart_param_config(UART_PORT, &uart_config);
    uart_set_pin(UART_PORT, UART_PIN_NO_CHANGE, RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_PORT, 1024, 0, 0, NULL, 0);
}

void app_main(void) {
    init_uart();
    printf("RDM6300 initialized. Waiting for tags...\n");

    uint8_t byte;
    uint8_t frame[13];

    while (true) {
        // Sync on the 0x02 start byte
        if (uart_read_bytes(UART_PORT, &byte, 1, pdMS_TO_TICKS(100)) == 1 && byte == 0x02) {
            int got = uart_read_bytes(UART_PORT, frame, 13, pdMS_TO_TICKS(100));
            if (got == 13 && frame[12] == 0x03) {
                char tag_hex[9];
                memcpy(tag_hex, frame + 2, 8); // skip the 2 version chars
                tag_hex[8] = '\0';
                unsigned long tag_id = strtoul(tag_hex, NULL, 16);
                printf("Tag detected: %s (decimal %lu)\n", tag_hex, tag_id);
            }
        }
    }
}

This ESP-IDF code configures a UART interface to communicate with the RDM6300 module. The init_uart function initializes the UART peripheral, and the app_main function continuously reads incoming tag data. The tag UID is logged to the console, making it suitable for integration into access control or identification systems.

RDM6300 ESPHome example

Copy
uart:
  rx_pin: GPIO16  # reader TX -> GPIO16; TX to the reader is not needed
  baud_rate: 9600

rdm6300:
  on_tag:
    - logger.log:
        format: "Tag scanned: %u"
        args: ['x']

binary_sensor:
  - platform: rdm6300
    uid: 7616525  # replace with your tag's ID (see the log line above)
    name: "RDM6300 Known Tag"

ESPHome has native RDM6300 support: the rdm6300 hub parses the reader's 125 kHz tag frames from UART (only RX is needed - reader TX to GPIO16). on_tag fires for every scan with the numeric tag ID, and a binary_sensor matches one specific tag. The old custom-platform example no longer works - that component was removed from ESPHome in 2025.

RDM6300 PlatformIO example

Copy
[env:rdm6300]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
src/main.cppCopy
#include <HardwareSerial.h>

HardwareSerial rfid(1);

void setup() {
    Serial.begin(115200);
    rfid.begin(9600, SERIAL_8N1, 16, 17); // RX, TX
    Serial.println("RDM6300 initialized. Waiting for tags...");
}

void loop() {
    if (rfid.available() > 0) {
        String tag = "";
        while (rfid.available() > 0) {
            char c = rfid.read();
            tag += c;
        }
        Serial.print("Tag detected: ");
        Serial.println(tag);
    }
    delay(500);
}

This PlatformIO code initializes a UART interface to communicate with the RDM6300 module. Incoming RFID tag data is read and displayed on the Serial Monitor. The loop function continuously checks for tag data and handles its output, making it suitable for quick prototyping or integration into other systems.

RDM6300 MicroPython example

Copy
from machine import UART, Pin
import time

# Initialize UART
uart = UART(2, baudrate=9600, tx=17, rx=16)

print("RDM6300 initialized. Waiting for tags...")

while True:
    if uart.any():
        tag = uart.read().decode('utf-8')
        print("Tag detected:", tag)
    time.sleep(0.5)

This MicroPython code sets up UART communication with the RDM6300 RFID module. The script continuously listens for incoming RFID tag data and prints the UID to the console. The simplicity of the code makes it ideal for quick prototyping or integration into identification projects.

RDM6300 specifications

From the datasheet
Communication Protocol
UART
Operating Voltage
5V (4.5V to 5.5V per datasheet)
Frequency
125kHz
Read Range
5-10cm
Operating Temperature
-10°C to +70°C
Dimensions
38mm x 22mm x 8mm

About the RDM6300

The RDM6300 is a 125 kHz low-frequency RFID reader, a different technology entirely from 13.56 MHz parts like the RC522 or PN532 - the frequency, the tags, and the whole ecosystem are unrelated, so an RDM6300 cannot read a MIFARE card and a MIFARE reader cannot read the fobs this module is built for. It targets EM4100/EM4102-compatible tags, the plain unencrypted fobs and cards common on older access-control and asset-tracking systems, and reports each tag over a single UART TX line at a fixed 9600 baud with no trigger or query needed from the host.

Each detected tag arrives as a 14-byte ASCII frame - a start byte, ten hex characters (a 2-character version field plus the 8-character tag ID), two checksum characters, and an end byte - simple enough to parse without a library, though ESPHome and a handful of Arduino libraries handle it directly. The module is read-only: it can report a tag’s ID but cannot write to one, even though EM4100-compatible tags exist in writable variants (like T5577) that other 125 kHz readers can program - a limitation confirmed by hobbyists who have had to build custom firmware specifically to add write support.

That simplicity is also the security weakness: a bare tag ID transmits in the clear with no encryption or challenge-response, and 125 kHz cards are trivially cloned with a cheap writer, so an RDM6300-based system is access convenience, not real security. At around 4 dollars it is a cheap way to add badge-style identification to a project, but if a design needs the encrypted, sector-keyed MIFARE ecosystem instead, the RC522 is the 13.56 MHz equivalent - just note that the two are not interchangeable at the tag level.

RDM6300 troubleshooting

5 common issues

Module Fails to Power On

›

Issue: The RDM6300 module does not power up or respond to commands.

Possible causes include insufficient power supply, incorrect wiring, or faulty hardware.

Solution: Ensure the module is connected to a stable power source within the recommended voltage range of 5V. Verify that all connections are secure and correctly configured. If the problem persists, consider testing the module with a different power source or replacing it.

Communication Interface Not Working

›

Issue: The module fails to communicate with the microcontroller over the chosen interface (typically UART).

Possible causes include incorrect wiring, improper interface selection, or incompatible voltage levels.

Solution: Double-check the wiring to ensure correct connections for UART communication. For UART, verify the TX and RX lines are properly connected. Ensure that the microcontroller's UART interface is enabled and configured correctly.

Unable to Read Tags

›

Issue: The module initializes correctly but fails to read RFID tags.

Possible causes include incorrect antenna orientation, insufficient power supply, or interference from nearby electronic devices.

Solution: Ensure the module's antenna is properly oriented and positioned near the tags. Verify that the power supply provides adequate current for the module's operation. Keep the module away from sources of electromagnetic interference.

Inconsistent Tag Detection

›

Issue: The module detects tags intermittently or with delays.

Possible causes include low-quality tags, environmental interference, or firmware issues.

Solution: Test with different tags to rule out tag quality issues. Ensure the operating environment is free from strong electromagnetic interference. Update the module's firmware to the latest version to benefit from bug fixes and improvements.

Library or Software Issues

›

Issue: The module operates erratically or produces errors during operation.

Possible causes include outdated or incompatible libraries, incorrect initialization, or software bugs.

Solution: Ensure that the latest version of the RDM6300 library is installed and compatible with your development environment. Review the initialization code to confirm that the module is set up correctly. Consult the module's documentation and community forums for guidance on proper usage.

Where to buy the RDM6300

RDM6300 RFID Reader Module
RDM6300 RFID Reader Module
$4.00per unit, typical
Amazon and AliExpress links are affiliate links - buying through them supports the site at no extra cost to you.

Resources

Similar sensors