Adafruit QT Py ESP32-S3
The Adafruit QT Py ESP32-S3 brings the ESP32-S3 into Adafruit's compact QT Py form factor with STEMMA QT (Qwiic) connectivity. At 22x17.8mm, it is designed for quick sensor integration using Adafruit's plug-and-play I2C ecosystem, with full CircuitPython and Arduino support out of the box.
Best for Adafruit STEMMA QT ecosystem projects, skip if you need PSRAM or many GPIO pins.
Where to Buy
Pros
- Built-in STEMMA QT / Qwiic connector for plug-and-play I2C sensors
- Excellent CircuitPython and Arduino support from Adafruit
- USB-C with OTG support for native USB functionality
- Adafruit's extensive tutorial and learning resources
Cons
- No PSRAM on the standard variant — limits AI/ML and camera applications
- Only 13 GPIO pins exposed — constraining for complex projects
- No battery charging circuit unlike the XIAO or Thing Plus
STEMMA QT Ecosystem
The defining feature of the QT Py is the STEMMA QT connector — a JST SH 4-pin connector compatible with SparkFun's Qwiic standard. This connector carries I2C data (SDA, SCL) plus 3.3V power and ground at up to 226mA. You can daisy-chain multiple I2C devices without any soldering or breadboarding — each sensor breakout has two STEMMA QT ports (in and out) for bus passthrough.
Adafruit sells over 200 STEMMA QT-compatible sensor breakouts covering temperature (BME280, SHT40), humidity, pressure, light (VEML7700, TSL2591), gas (SGP40, BME688), accelerometers (LIS3DH, LSM6DSOX), gyroscopes, magnetometers (LIS3MDL), GPS (PA1010D), and more. Each comes with a CircuitPython library that installs by copying a .mpy file to the board's USB drive. For educators and rapid prototypers, this plug-and-play ecosystem eliminates wiring errors and reduces setup time from hours to minutes.
The cross-compatibility with SparkFun's Qwiic ecosystem doubles the available sensor options. Any Qwiic breakout from SparkFun connects directly to the QT Py's STEMMA QT port using the same JST SH cable. This interoperability gives the QT Py access to roughly 500+ plug-and-play I2C devices across both ecosystems — the largest solderless sensor library available for any microcontroller platform.
CircuitPython First
While all ESP32-S3 boards support Arduino and ESP-IDF, the QT Py is optimized for CircuitPython. Adafruit preloads CircuitPython firmware, and the board appears as a USB drive (CIRCUITPY) when connected. You write Python code in any text editor, save it to the drive as code.py, and it runs immediately — no compilation, no flashing, no IDE required. Error messages appear on the serial console in real time, and editing code.py automatically restarts the program within 500ms.
The 8MB flash provides ample space for CircuitPython (approximately 1MB for the interpreter), the library bundle (300+ drivers at roughly 2MB), and application code. CircuitPython's trade-off is performance — it is interpreted Python running on a microcontroller, delivering roughly 5-10% of the throughput of compiled C/C++ via Arduino or ESP-IDF. For sensor reading at 1-10 Hz, I2C communication, and data logging, the performance is more than adequate. For time-critical operations like driving NeoPixels or SPI displays, CircuitPython uses compiled native modules that run at near-C speed.
Adafruit's learning system contains over 300 guides specifically written for CircuitPython on STEMMA QT hardware, making the QT Py the most thoroughly documented path from zero to working sensor project in the entire ESP32 ecosystem. The educational value cannot be overstated — students write real Python, not a simplified subset, and the skills transfer directly to Raspberry Pi, desktop Python, and professional development.
Hardware Trade-offs
The standard QT Py ESP32-S3 ships without PSRAM, which is a significant limitation compared to the XIAO ESP32S3 or the DevKitC that include 8MB. Without PSRAM, camera frame buffers (150KB+ per VGA frame) and ML model weights (typically 200KB-2MB) cannot be loaded into external memory. An N8R2 variant with 2MB PSRAM exists but is less commonly stocked at major retailers and may require ordering directly from Adafruit.
The 13 GPIO pins and single STEMMA QT connector are sufficient for typical sensor projects but limit hardware complexity. You get 1 SPI bus, 1 I2C bus (on the STEMMA QT connector), 1 UART, and 4 ADC channels at 12-bit resolution. For most STEMMA QT sensor chains — daisy-chaining 3-5 I2C sensors plus an SPI display — this is adequate. The constraint surfaces when you need multiple independent SPI devices or more than 4 analog inputs.
There is no battery charging circuit — you need an external charger or a different board for portable applications. The XIAO ESP32S3 offers built-in LiPo charging in a similar form factor, and the SparkFun Thing Plus ESP32-S3 adds a fuel gauge and MicroSD slot for field deployments. The QT Py's niche is specifically plug-and-play wired prototyping with the STEMMA QT ecosystem, not portable or battery-powered devices.
Adafruit Ecosystem and STEMMA QT
The QT Py's value proposition extends far beyond the hardware specs — it is a gateway into Adafruit's vertically integrated ecosystem of boards, sensors, software, and education. The STEMMA QT connector (electrically identical to SparkFun's Qwiic standard) uses a JST SH 4-pin plug carrying I2C data, 3.3V power, and ground. Connecting a sensor requires zero soldering, zero breadboarding, and zero wiring mistakes — you plug in a cable and write 3-5 lines of CircuitPython to read data. For educators introducing physical computing, this eliminates the most common failure point: incorrect wiring.
Adafruit's STEMMA QT sensor catalog exceeds 200 breakouts spanning environmental monitoring (BME680 for temperature, humidity, pressure, and VOC gas at $19), motion sensing (LSM6DSOX 6-DoF IMU at $12), light measurement (VEML7700 lux sensor at $5), distance ranging (VL53L4CD ToF sensor at $8), and specialized inputs like soil moisture, UV index, and particulate matter. Each breakout has two STEMMA QT ports — one in, one out — enabling daisy-chaining up to the I2C bus limit of 127 devices. A typical classroom project chains 3-4 sensors: temperature + humidity + light + motion, all connected with 50mm cables, reading data in under 20 lines of Python.
CircuitPython is the first-class programming environment, and this is where Adafruit's ecosystem integration shines. The QT Py ships with CircuitPython preloaded — plug it into USB and a CIRCUITPY drive appears. Drop a code.py file onto the drive and it executes within 500ms. No IDE installation, no compiler toolchain, no board manager configuration. Every STEMMA QT sensor has a matching CircuitPython library available in the Adafruit CircuitPython Bundle (300+ drivers), installable by copying a single .mpy file to the board's lib folder. Adafruit's Learning System hosts over 300 project guides written specifically for CircuitPython on STEMMA QT hardware, with wiring diagrams, code walkthroughs, and troubleshooting sections.
The 22x17.8mm form factor enables projects that larger boards cannot serve. Wearable sensor badges for conferences or classrooms, embedded environmental monitors inside 3D-printed enclosures as small as 30x25mm, compact USB input devices using the S3's native USB-OTG for HID emulation, and space-constrained art installations where the controller must be invisible. The QT Py fits inside a ping-pong ball with room for a STEMMA QT sensor cable routed through a drilled hole — a popular form factor for classroom data logging projects where students place sensor nodes around the school.
Full Specifications
Processor
| Specification | Value |
|---|---|
| Architecture | Xtensa LX7 [1] |
| CPU Cores | 2 [1] |
| Clock Speed | 240 MHz [1] |
Memory
| Specification | Value |
|---|---|
| Flash | 8 MB [1] |
| SRAM | 512 KB [1] |
Connectivity
| Specification | Value |
|---|---|
| WiFi | 802.11 b/g/n [1] |
| Bluetooth | 5.0 [1] |
I/O & Interfaces
| Specification | Value |
|---|---|
| GPIO Pins | 13 [2] |
| ADC Channels | 10 [2] |
| SPI | 1 [2] |
| I2C | 1 [2] |
| UART | 1 [2] |
| USB | USB-C (OTG) [2] |
| STEMMA QT / Qwiic | 1x STEMMA QT / Qwiic [2] |
Power
| Specification | Value |
|---|---|
| Input Voltage | 5 V [1] |
| Deep Sleep Current | ~15 uA [1] |
Physical
| Specification | Value |
|---|---|
| Dimensions | 22 x 17.8 mm [2] |
| Form Factor | QT Py (Adafruit compact) [2] |
Who Should Buy This
The STEMMA QT connector lets you daisy-chain Adafruit's 200+ I2C sensor breakouts without soldering. CircuitPython firmware is preloaded. Plug in, write Python, read sensors.
CircuitPython turns the board into a USB drive where you edit code in a text editor. No IDE, compiler, or toolchain setup needed. Adafruit's tutorials and guides are beginner-friendly.
No PSRAM on the standard QT Py variant means no room for camera frame buffers or ML models. The ESP32-S3-DevKitC has 8MB PSRAM for these applications.
Better alternative: ESP32-S3-DevKitC-1
No battery charging circuit. The XIAO ESP32S3 offers a similar form factor with built-in LiPo charging, and the Thing Plus ESP32-S3 adds a fuel gauge.
Better alternative: Seeed Studio XIAO ESP32S3
Ecosystem & Community
The QT Py lives in Adafruit's STEMMA QT ecosystem with 200+ plug-and-play I2C sensors, extensive CircuitPython libraries, and beginner-friendly learning guides.
Compatible Software
What to Build First
Daisy-chain multiple STEMMA QT sensors (temperature, light, accelerometer) to the QT Py using plug-and-play cables. Read all sensors in 10 lines of CircuitPython — demonstrates the power of the Adafruit I2C ecosystem.
View tutorial →Must-Have Accessories
Tutorials & Resources
- Adafruit QT Py ESP32-S3 Learning GuideComprehensive guide covering setup, CircuitPython, Arduino, pinout, and STEMMA QT usagetutorial
- CircuitPython Libraries Bundle300+ pre-built CircuitPython drivers for sensors, displays, and communication protocolsdocs
- STEMMA QT Sensor Ecosystem OverviewIntroduction to the STEMMA QT/Qwiic plug-and-play I2C sensor ecosystem and compatible boardstutorial
Frequently Asked Questions
What is STEMMA QT / Qwiic?
STEMMA QT (Adafruit) and Qwiic (SparkFun) are the same JST SH 4-pin I2C connector standard. Boards and sensors from both companies are cross-compatible. You connect them with small cables — no soldering needed.
Does the QT Py ESP32-S3 have PSRAM?
The standard variant does not include PSRAM. An N8R2 variant with 2MB PSRAM exists but is less common. For 8MB PSRAM, consider the XIAO ESP32S3 or the ESP32-S3-DevKitC.
Can I use Arduino with the QT Py ESP32-S3?
Yes. While Adafruit emphasizes CircuitPython, the QT Py fully supports Arduino IDE and PlatformIO via the ESP32 Arduino Core. You can switch between CircuitPython and Arduino by flashing different firmware.
QT Py vs XIAO ESP32S3: which is better?
The QT Py wins on ecosystem (STEMMA QT connector, CircuitPython focus, Adafruit tutorials). The XIAO wins on specs (8MB PSRAM, battery charging, camera option with Sense variant). Both are similar size at around 21-22mm.
How many I2C sensors can I connect to the QT Py?
Up to 127 devices on the single I2C bus, though practically 10-20 is common. STEMMA QT cables daisy-chain, so each sensor board passes the bus to the next. Address conflicts are the main limitation — most sensors have configurable I2C addresses.