ESP32 OTA services compared: which one fits your fleet

Updating ESP32 firmware over the air can mean a library that puts an upload page on the board, or a cloud service that manages thousands of devices. Which approach fits depends on how many devices you have, where they are, and what else you need besides the update.

This post covers the options that come up most often: rolling your own, ArduinoOTA, ElegantOTA, Arduino Cloud, Blynk, ESP RainMaker, Golioth, Memfault, AWS IoT, Azure IoT Hub, Mender and SimpleOTA.

We build SimpleOTA, so read this knowing that. We’ve described every other option from its own documentation, and linked those docs so you can check us. Everything here was checked on 10 October 2026. Products change, so treat pricing in particular as a snapshot.

In this post: the short answer · where they differ · comparison tables · each option in detail · matching the option to the job · FAQ

The short answer

• One board on your desk: ArduinoOTA or ElegantOTA. Either library is free, so setup amounts to adding it to the sketch you already have on the bench.
• A few devices, and you like building infrastructure: roll your own on ESP-IDF’s esp_https_ota or Arduino’s HTTP update helpers.
• You have an ESP32 fleet that needs staged rollouts, signed images and rollback, without running servers: SimpleOTA.
• You already use Arduino Cloud, Blynk or ESP RainMaker for the app: use the OTA that comes with it.
• You want crash reports, metrics and OTA in one place: Memfault or Golioth.
• Your devices connect to AWS IoT: AWS IoT Jobs with the AWS IoT OTA library.
• Your devices connect to Azure IoT Hub: Device Update for IoT Hub, if you can own the ESP32 side yourself.
• You run Zephyr, or Linux gateways alongside microcontrollers: Mender, on a hosted plan for the microcontroller tier.

Tap or click the flowchart to open it full size.

Where they differ

Under the hood, every option does the same thing. It writes a new image into the ESP32’s spare app partition and switches to it. If that’s new to you, start with how ESP32 OTA updates work.

The differences sit in everything around that step. Local tools push a build from your computer, while a fleet service waits for each device to check in, so the device can pull the image itself. Sending the build to 5% of devices first gives you a slice you can watch, which is what tells you whether to widen it. A new build that boots but fails to run is a different question, because some options revert it on their own while others leave the recovery to you. Refusing an image that was not signed with your key is its own property, since that check is what stops a compromised file from becoming the firmware the device runs.

Some come bundled with a whole IoT platform, which is only worth it if you’ll use the platform. Several support only one of Arduino, ESP-IDF, or Zephyr. Hosting is its own decision: a service someone else runs, a server you install, or the cloud account you already pay for. The price follows from that decision, as a charge per device, a plan, or measured usage.

At a glance

Toolchain, hosting and pricing

Option	Works with on ESP32	Where it runs	Pricing model
Roll your own	ESP-IDF, Arduino	Your server or storage	Your hosting costs
ArduinoOTA	Arduino	On your own network	Free, in the ESP32 Arduino core
ElegantOTA	Arduino	On the device	Free; Pro is a paid licence
Arduino Cloud	Arduino	Hosted	OTA on paid plans only
Blynk	Arduino (Blynk.Edgent)	Hosted	Free for 5 devices; tiers by device count
ESP RainMaker	ESP-IDF, Arduino	Espressif’s public cloud, or your own instance	Public cloud is free, with a limited quota
Golioth	ESP-IDF, Zephyr	Hosted	Per connected device, plus per MB
Memfault	ESP-IDF	Hosted	Free plan is Nordic-only; OTA is a paid add-on
AWS IoT	ESP-IDF (AWS IoT OTA library)	Your AWS account	Per job action, plus messaging
Azure IoT Hub	ESP-IDF (sample only)	Your Azure subscription	Standard tier hub, plus a monthly charge per device
Mender	Zephyr (with MCUboot)	Hosted for microcontrollers	Hosted plans priced by device count
SimpleOTA	Arduino, ESP-IDF	Hosted	Free for 5 devices; plans by device count

Rollouts, rollback and signing

Option	Staged rollouts	Rollback	Signed updates	Also includes
Roll your own	You build it	ESP-IDF app rollback, which you wire up	ESP-IDF signed app verification	Nothing
ArduinoOTA	No: one board at a time	Not documented	Not documented	Local push, usually over mDNS
ElegantOTA	No: one device at a time	Not documented	MD5 integrity check	An upload page on the device
Arduino Cloud	Not documented; bulk upload by tag from the CLI	Not documented	Not documented	Dashboards, Cloud Editor
Blynk	Not documented; ships to all or selected devices	Not documented	Not documented	Mobile app, dashboards, provisioning
ESP RainMaker	By node and node group	Yes	Yes, tied to Secure Boot	Phone app, voice assistants
Golioth	By cohort	New deployment of the previous version	Not documented	Data streaming, pipelines, logs
Memfault	Yes, by percentage	Recover by re-releasing a higher version	Recommended	Crash reports, metrics
AWS IoT	Rollout rates and abort thresholds	Self-test before the image is committed	Yes	MQTT, rules, device shadows
Azure IoT Hub	By device group, with a scheduled start	Sends a fallback version past a failure threshold	Manifests signed with Microsoft’s keys	MQTT, device twins, direct methods
Mender	Phased rollouts on Enterprise	Automatic, through MCUboot	Not supported on microcontrollers	Linux device updates
SimpleOTA	By percentage, per group and channel	Trial boot that rolls back if unconfirmed	Optional Ed25519, with your key; SHA-256 check always	Nothing: it only does OTA

“Not documented” means we couldn’t find it in that vendor’s own OTA documentation. It may well exist, so ask them before ruling it out.

On your desk: ArduinoOTA and ElegantOTA

Both of these update a board you can reach on your own network. ArduinoOTA ships with the ESP32 Arduino core and lets your computer push a sketch to a board on the same Wi-Fi, usually finding it with mDNS. ElegantOTA puts an upload page at /update on the device itself: you open it in a browser and drop in a .bin. It checks the upload with an MD5 hash and shows live progress. The paid Pro version adds update channels, and a mode where the device fetches firmware from a URL itself.

Neither tracks which build each device runs, rolls a release out gradually, or reaches a board that has left your network. They’re built for the bench. ArduinoOTA vs managed fleet OTA covers the point where a project outgrows them.

If the boards are on your desk or your own network, and you’re the only one updating them, these are all you need.

Build it yourself: esp_https_ota and GitHub Releases

ESP-IDF’s esp_https_ota downloads an image over HTTPS and writes it to the spare partition, and Arduino-ESP32 has HTTP update helpers that do the same. Put the binary on any HTTPS host, have devices check a version file, and you have internet OTA.

ESP-IDF also supplies two of the hard parts. The first is app rollback, which reverts a build that never confirms itself healthy. It’s on by default from ESP-IDF 6.2, but the default confirms the new app automatically at startup, so to gate it on a real health check you confirm from your own code instead. The second is signature verification on update, which works without hardware Secure Boot.

If you don’t want to host anything, libraries such as esp_ghota pull firmware straight from a GitHub release. For a private repository that means putting an access token on the device, which its own docs warn is easy to extract from the firmware image.

What you’re signing up to build is everything above the download: deciding which devices get which build, staging a release, stopping a bad one, and knowing which devices actually took it. For a handful of devices that can be a version file and a spreadsheet. For a few hundred it’s a small product of its own.

This makes sense with a few devices, or with requirements no service meets, as long as you’re happy to build and run the update server yourself.

Platforms with OTA built in: Arduino Cloud, Blynk and ESP RainMaker

These are full IoT app platforms, with dashboards, phone apps and device control, and OTA is one feature among many. If you’re already building on one, its OTA is usually the right call, because your devices are enrolled and identified there.

Arduino Cloud supports OTA on all ESP32 and ESP8266 boards, from the web interface or the command line. OTA isn’t on the free plan. The Cloud CLI can mass-upload one binary to many devices, picked by device ID or by tag. We couldn’t find staged rollouts, rollback or firmware signing in its OTA documentation.

Blynk ships updates through Blynk.Air to devices running firmware built on Blynk.Edgent. A shipment goes to every device made from a template, or to the ones you pick. Its docs don’t describe staged rollouts, rollback or signing. The free plan covers 5 devices and includes a couple of OTA campaigns, and paid plans scale by device count.

ESP RainMaker is Espressif’s own platform, with an SDK for ESP-IDF and a library for Arduino. It’s the strongest OTA of the three: it targets nodes, node groups, or dynamic groups based on attributes such as firmware version, and it supports rollback and signed images tied to Secure Boot. The public RainMaker cloud is free but meant for evaluation, with a limited device quota. A production fleet runs its own private instance, arranged through Espressif.

If you want the app, dashboards or phone control anyway, use the OTA that comes with them. RainMaker in particular suits consumer and smart-home products.

Device platforms: Golioth and Memfault

Both pair OTA with data about how your devices behave in the field.

Golioth supports ESP32 through its Firmware SDK for ESP-IDF, alongside Zephyr. Devices receive a release manifest over CoAP and update from it. You group devices into cohorts, and each cohort has one active deployment at a time. A deployment cannot be retracted, so rolling back means issuing a new deployment of the previous version. Around OTA you get data streaming, data pipelines and logs. Pricing is usage-based with no plan tiers: a monthly charge per connected device plus per-MB charges. Every new account includes $50 in usage credits.

Memfault is built around debugging fleets: crash reports, coredumps and metrics, with OTA alongside. Its ESP-IDF component is tested on several ESP32 variants. Devices poll Memfault’s OTA endpoint, releases go to cohorts, and a release can be activated for a percentage of a cohort at a time. To roll back, Memfault recommends shipping the old build again under a higher version. Note the pricing: its free plan is exclusively for Nordic-based teams, the published paid plans start at several thousand dollars a month, and OTA is an optional add-on on all of them.

These earn their price when the hard problem is working out why devices misbehave in the field.

Cloud infrastructure: AWS IoT and Azure IoT Hub

AWS doesn’t sell an ESP32 OTA product so much as the parts to build one. You create an OTA update, AWS turns it into an IoT job, and the AWS IoT OTA library on the device downloads the image over MQTT or HTTP, checks its signature, and installs it. New images run a self-test before they’re committed.

The rollout controls are the most thorough here. You can set a constant or exponential rollout rate, abort automatically when a threshold percentage of devices fails or times out, retry failures, and schedule rollouts into maintenance windows. You sign images with Code Signing for AWS IoT or your own tools. Pricing is per remote action, with each device in a job counting as one, plus IoT Core messaging billed separately. There’s a 12-month free tier.

The downside is that you assemble it all yourself. Accounts, certificates, IAM, signing profiles and the device library are yours to wire together and maintain.

Azure has a managed OTA service, Device Update for IoT Hub. You import an update, tag devices into groups, and deploy to a group, now or at a scheduled time. A deployment can carry an automatic rollback policy: once a set number or percentage of devices fail, Device Update moves devices to a fallback version you named.

Device Update signs each update’s manifest, and the device checks that signature against Microsoft’s root keys before it trusts the file hashes inside. That chain of trust ends at Microsoft’s keys, and the security docs don’t describe a way to sign with your own.

Device Update needs a Standard tier IoT hub, and it’s billed per instance and per device each month, with up to 10 devices free for evaluation.

The catch on ESP32 is the device side. Device Update’s supported platforms are Linux distributions, and Microsoft points microcontroller users to Eclipse ThreadX samples for STMicroelectronics, NXP, Renesas and Microchip boards. ESP32 isn’t on either list. For ESP32 there’s a Microsoft sample, built on ESP-IDF and tested against ESP-IDF 4.4.3. Treat it as a starting point. As written, it compiles the device’s credentials into the image, so each update suits one device.

The bigger issue is what the sample is built on. It uses Microsoft’s Azure IoT middleware for FreeRTOS, which sits on the Azure SDK for Embedded C. That SDK is deprecated and gets no security fixes or new features, and the Arduino version of that SDK is archived. Microsoft’s newer unified IoT SDKs are still in preview.

AWS makes sense when your devices already talk to AWS IoT Core. It also makes sense when the rest of the company already lives in one AWS account, since that is where the jobs, certificates, and signing profiles will sit. Azure makes sense when your devices already connect to IoT Hub, because that connection only helps if you are prepared to own the ESP32 client code, which means maintaining it as well.

Linux-first: Mender

Mender is best known for updating embedded Linux devices. Microcontroller support is generally available. On a microcontroller it runs under Zephyr with MCUboot, which handles atomic updates and automatic rollback. The reference board is an ESP32-S3 running Zephyr. So an ESP32 project on ESP-IDF or Arduino would need to move to Zephyr first.

Microcontrollers sit on a separate “micro” device tier, with longer polling intervals and smaller updates than Linux devices. That tier gets basic full-image updates and inventory data, and Mender’s docs list signed artifacts and delta updates among the features it doesn’t support.

The open-source server is free to self-host for Linux devices. An ESP32 on Zephyr uses the Micro device tier, which Mender offers only on hosted plans. Hosted plans are priced by device count. Scheduled deployments come with the Professional plan, and phased rollouts with Enterprise.

It fits teams already on Zephyr, or teams running Linux gateways next to microcontrollers, when the microcontroller updates can live on a hosted plan.

Focused OTA: SimpleOTA

SimpleOTA is an OTA service for ESP32 fleets, and nothing else. It has first-party clients for Arduino and ESP-IDF, and you upload builds from CI or the dashboard.

A deployment targets device groups, release channels or both, at a percentage. Each device lands in a stable cohort, so raising the percentage adds devices without reshuffling the ones already in. You can pause, widen or cancel a rollout, and the dashboard shows which devices confirmed, failed or rolled back.

Devices download straight from storage using a time-limited URL. They write the image to the spare partition while hashing it, and only mark it bootable if the SHA-256 matches. With signing on, the Ed25519 signature has to verify too. SimpleOTA stores only the public key: you bring your own key pair, or generate one in the dashboard and download the private key once. A new build boots as a trial and rolls back on its own if it doesn’t confirm it’s healthy in time.

It’s free for up to 5 devices, and paid plans scale by device count. The staged rollout guide shows a canary in practice.

What SimpleOTA doesn’t do

If any of these is a dealbreaker, you can rule it out now:

• ESP32 only. The clients and compatibility rules target the ESP32 family.
• OTA only. No telemetry, MQTT broker, device shadows or remote commands. If you need those, pair it with something else, or pick a platform that has them.
• Pull, not push. Devices check in on their own schedule, so an update can’t be forced onto a device instantly.
• Hosted only. There’s no self-hosted edition. The client libraries are open source under the MIT licence.
• Full images. There are no delta updates, so every update downloads the whole binary.

It fits an ESP32 fleet in the field that needs staged rollouts, signing and rollback, when you’d rather not build or run an update server.

Matching the option to the job

If you’re…	Look at	Why
Tinkering with one or two boards	ArduinoOTA, ElegantOTA	Free, local, no setup
Shipping a maker product to tens of devices	SimpleOTA, or Blynk if you want its app	Fleet updates without running servers
Running ESP32 fleets for several clients	SimpleOTA, or roll your own	A project per client, rollouts per group
Building a consumer smart-home product	ESP RainMaker	Phone app and voice assistant support
Debugging failures in the field	Memfault, Golioth	Crash data and metrics next to OTA
Already all-in on AWS	AWS IoT	One account, the deepest rollout controls
Already all-in on Azure	Azure IoT Hub with Device Update	Group deployments with automatic rollback, if you own the ESP32 client
Running Linux gateways and microcontrollers	Mender	One update system for both, hosted for microcontrollers

Frequently asked questions

Is there a free OTA service for ESP32?

Several, with limits. ArduinoOTA, ElegantOTA and rolling your own cost nothing but your time and hosting. Among hosted options, Blynk’s free plan covers 5 devices with a few OTA campaigns, SimpleOTA is free for 5 devices, Espressif’s public RainMaker cloud is free for evaluation, and Golioth includes $50 in usage credits on every new account. Azure’s Device Update is free for up to 10 devices, but it needs a paid Standard tier IoT hub. Arduino Cloud doesn’t include OTA on its free plan, and Memfault’s free plan is only for Nordic hardware.

Can I update an ESP32 over the internet without running a server?

Yes. Any of the hosted services handles the server side. If you’d rather not use a service, a GitHub-release updater like esp_ghota works, but you give up staged rollouts and any record of which devices updated. And a private repository means shipping an access token in the firmware.

Does Arduino Cloud OTA work with ESP32?

Yes. Arduino Cloud supports OTA on all ESP32 and ESP8266 boards, but only on its paid plans. Its OTA documentation doesn’t cover staged rollouts, rollback or firmware signing.

Does Mender support ESP32?

Yes. Microcontroller support is generally available: an ESP32 uses it through Zephyr with MCUboot on a hosted plan, with the ESP32-S3 as the reference board. The Micro device tier is not included with self-hosted Mender, so a project that must self-host would not take this path. Signed artifacts aren’t supported on microcontrollers, so this ESP32 path cannot offer them. A project built on ESP-IDF or Arduino would need to move to Zephyr to use it, since that is the stack the support runs on.

Does Azure IoT support ESP32 OTA?

Partly. Device Update for IoT Hub can deploy ESP32 firmware, and Microsoft publishes an ESP-IDF sample that does it. But the sample sits on the Azure SDK for Embedded C, which Microsoft has deprecated, so a production ESP32 client is code you’d own and maintain. On the cloud side, Device Update needs a Standard tier IoT hub.

Which ESP32 OTA options support staged rollouts?

Memfault and SimpleOTA roll out by percentage. AWS IoT controls the rollout rate and aborts on failure thresholds. Azure Device Update deploys to device groups and rolls back automatically past a failure threshold. Mender offers phased rollouts on its Enterprise plan. Golioth and ESP RainMaker target groups of devices, and we couldn’t find percentage rollouts in their docs. If you roll your own, you build it.

Do I need signed firmware for OTA?

It’s not required, but it’s what stops a device installing an image you didn’t make, even if your server or storage is compromised. Signing during OTA protects the update path. It doesn’t replace ESP32 Secure Boot, which stops unsigned firmware from running at all, including firmware flashed by hand. The signed firmware guide covers how SimpleOTA does it.

How we checked

Every claim about another product comes from that product’s own documentation, pricing page, or pricing post, linked inline above, and was checked on 10 October 2026. Where a vendor’s OTA documentation didn’t cover something, we’ve said “not documented” rather than guessing. If we’ve got something wrong, or something has changed, email [email protected] and we’ll fix it.