See inside every ESP32 you ship.

Remote access to the device's web server, live and stored logs, metrics, crash reports with decoded backtraces and OTA updates with rollback, in 9.4 KB of RAM. One line of code on ESP-IDF, Arduino or PlatformIO.

Adding it

idf.py add-dependency "pinscope/pinscope"

pinscope_start(NULL);   /* once WiFi is up; the key is in menuconfig */

What you get

• Its web server from anywhere: an HTTPS address for the HTTP server already on the device, behind your login, a share link or an API token. No port forwarding, no VPN.
• Logs: live and stored, searchable, from the device's normal log output.
• Health: memory, stack, signal, uptime and restarts without code, and your own numbers with one call.
• Crashes: kept across the reboot and decoded with the ELF of the build.
• Updates: from the dashboard, with the platform's own fallback when the new firmware does not come back.
• Alerts: email or webhook when a device goes offline or crashes.

Free tools

• ESP32 exception decoder
  Paste an ESP32 crash (Guru Meditation, backtrace or RISC-V stack dump), choose the ELF, get functions and lines. The ELF is not uploaded.
• ESP32 log analyzer
  Paste an ESP32 serial log: reset reasons, crashes, watchdogs, brownouts, esp_err_t codes and WiFi disconnect reasons explained, with fixes.
• ESP32 core dump decoder
  Decode an ESP-IDF core dump in the browser: paste the UART base64 or load the partition, add the ELF, see every task's backtrace.
• ESP32 firmware inspector
  Drop an ESP32 .bin: chip, version, project, build date, ESP-IDF version, flash settings, segments, checksum and SHA-256. Merged images too.
• ESP32 partition table editor
  Lay out an ESP32 partitions.csv on a map of the flash, check OTA slots and sizes, and save the CSV or the binary, as gen_esp32part.py makes it.
• ESP32 NVS editor
  Generate an ESP32 NVS partition, open an nvs.bin to see every key, edit it, and read or write a device over USB. Same as nvs_partition_gen.py.
• ESP32 serial monitor
  A serial monitor in Chrome or Edge: colored log levels, reset, filter, errors explained and ESP32 or Zephyr crashes decoded live with your ELF.
• ESP32 web flasher
  Flash ESP32 firmware from Chrome or Edge: offsets from the files or flash_args, chip checked, erase and full backup. Built on esptool-js.
• ESP32 GPIO guide: which pins are safe
  Which GPIOs of the ESP32, S2, S3, C2, C3, C6 and H2 are free, and which are strapping, flash, PSRAM, USB or input only. With ADC, touch and RTC pins.
• sdkconfig diff
  Compare two ESP-IDF sdkconfig files: differences grouped by component, the settings that change behaviour in the field explained, and a minimal sdkconfig.defaults.

Guides

• Remote access to an ESP32 without TLS: what it measured and what it costs
  Why the Pinscope device component uses the Noise protocol instead of TLS, what it measured on an ESP32-S2, and what that choice costs.
• Reaching an ESP32 web server from outside its network
  Four ways to reach an ESP32 web server behind NAT or a router: port forwarding, a VPN, MQTT and an outbound tunnel, and what each one costs.
• Updating ESP32 firmware over the internet, with rollback
  What ESP32 OTA firmware updates need when the device is not on your network: two OTA partitions, a way to deliver the image, and a rollback.
• Guru Meditation Error: decoding the backtrace, and crashes from the field
  What a Guru Meditation Error means, how to decode its backtrace to function and line (addr2line, or an online decoder), and how to get crashes from devices with no serial cable.
• Remote logging: ESP_LOG without a serial cable
  How to get ESP_LOG output from an ESP32 that is not on your desk: hooking the log with esp_log_set_vprintf, where to send it, and the mistakes that crash the device.
• Heap and stack monitoring in the field
  Which ESP32 memory numbers to watch in the field: free heap, minimum free heap, largest free block and the stack high-water mark of each task, and what each one tells you.
• An ESP32 behind CGNAT, 4G or Starlink
  Why an ESP32 on a 4G router, Starlink or a carrier-grade NAT connection cannot be reached by port forwarding or dynamic DNS, and what works instead.
• TLS memory usage on the ESP32, and how to reduce it
  How much heap one mbedTLS connection takes on an ESP32, measured, and the menuconfig options that reduce it: dynamic buffers, smaller record sizes and what each one costs.
• Sharing an ESP32 sensor page with anyone, without port forwarding
  An ESP32 already serves its readings on your WiFi. How to give that page a public HTTPS address, and how to write it so many visitors at once do not take the device down.
• ArduinoOTA over the internet, with a rollback
  Why ArduinoOTA only works on your own network, and how to update an ESP32 Arduino sketch from anywhere, with a rollback if the new firmware cannot connect.
• ESP32 remote access compared: port forwarding, ngrok, Cloudflare Tunnel, Tailscale
  Five ways to reach an ESP32 web server from outside its network, compared on what each needs, where it runs and what it costs, as of November 2026.
• esp_http_server slow? The 250 ms delay and the fix
  Why every response from ESP-IDF esp_http_server can take about 250 ms, on the LAN and through a tunnel, and how TCP_NODELAY in open_fn removes it.
• Before the first ESP32 ships: a field support checklist
  What to have in an ESP32 product before it leaves for customers: remote access, logs, crash reports, OTA with rollback, and knowing which firmware each device runs.
• ESP32 and VPNs: server, WireGuard client, or no VPN at all
  Can an ESP32 run a VPN server? What a WireGuard client on the ESP32 takes, when a VPN on the router or a Raspberry Pi is the better place, and reaching the device without a VPN.
• Pinscope now runs on Zephyr, Raspberry Pi Pico, Linux and ESP8266
  Remote access, logs, crash reports and OTA updates, as on the ESP32, now for Zephyr, the Pico 2 W, Linux and the ESP8266. About 9 KB of RAM.
• Memfault vs Pinscope: which one fits
  Memfault and Pinscope side by side: what each does, which devices they support, how they are priced, and when each one is the better choice.
• Golioth vs Pinscope: which one fits
  Golioth and Pinscope side by side: device management services, supported SDKs, usage-based versus fixed pricing, and when each fits.
• Memfault, Golioth, nRF Cloud and Pinscope compared
  Device management and observability for embedded fleets compared: Memfault, Golioth, nRF Cloud and Pinscope, by features, platforms and pricing.
• The Cyber Resilience Act, for the devices you ship
  What the EU Cyber Resilience Act asks of device makers, and when: an SBOM, handling vulnerabilities, security updates, a support period, reporting. What Pinscope does for it, and what it does not.
• SBOMs and known vulnerabilities for ESP32 and Zephyr firmware
  Pinscope now keeps the SBOM of each build, checks it against the NVD every day with the same matching as idf.py sbom-check, and shows which devices run an affected build.

Other platforms: Zephyr · Raspberry Pi Pico · Linux · ESP8266