๐ฆ rusteero
Async Rust client for the Eero mesh Wi-Fi cloud API
rusteero is a Rust client library for the Eero (Amazon) mesh Wi-Fi cloud API.
It is a port of the Python eero-api library at v8.0.4: same raw JSON contract, same method names, same credential record.
Status ยท Quick Start ยท Docs ยท Acknowledgments ยท License
โก Why rusteero?
- ๐ Async-first โ
tokio+reqwest(rustls), no Python runtime - ๐ฆ Raw JSON โ every call returns the exact
{meta, data}envelope Eero sends, wrapped in a losslessEnvelope - ๐ Link-aware โ every resource argument accepts a bare id, an API path or an absolute API-host URL, and every domain method takes a
parentenvelope so the request follows the link the API published - ๐ Secure โ session tokens are
SecretStrings sent only to the configured API host, redirects are refused, error messages never embed a response body - ๐ Compatible โ the
{"session_id", "schema_version": 2}credential record is shared witheero-api, so a login made byeeroctlworks unchanged (legacy records are migrated on first load) - ๐งฉ Headless-friendly โ the email/SMS code step is separable; inject a pre-obtained token instead
๐ง Status
Ported to eero-api 8.0.4, not yet released. Transport, authentication, credential storage,
the error catalogue, link resolution, all 37 domain modules, the Client facade and its cache are
in place, each pinned by wiremock tests. PARITY.md is the method-by-method table
against the Python library at tag v8.0.4: 267 rows โ 218 ported, 22 changed with a reason,
20 dropped with a reason, 3 identical, 4 renamed; none planned.
Nothing is published to crates.io until the library is validated against a live account and the author signs off.
๐ฆ Install
Not on crates.io yet โ use the git dependency:
[]
= { = "https://github.com/fulviofreitas/rusteero" }
# Headless / embedded (no system keyring):
= { = "https://github.com/fulviofreitas/rusteero", = false }
๐ Quick Start
Build a Client
use ;
async
ClientBuilder::build() is async because it may load a session from a configured
credential store. A Client persists nothing unless you attach one โ the system keyring
(default keyring feature) uses the same entry the Python library does. See
Configuration.
A write: read, compare, skip
Writes are only issued after a read shows the value actually differs. Most writes have not been
characterised against a live network and log one WARNING before the request; a
settings-class write such as set_sqm may reboot the whole mesh.
use json;
let current = client.get_sqm_settings.await?; // whole network object
if current.data != json!
Ids, paths, URLs and parent
Wherever a method takes a network_id, eero_id, device_id or profile_id, you may pass a
bare id, the resource's API path (/2.2/networks/<id>) or its absolute URL on the API host;
anything on another host or scheme is rejected with Error::Validation before a request is sent.
Every method on the domain modules (client.api().networks(), โฆ) also takes
parent: Option<&Value> โ the envelope you already hold โ and resolves its URL from the link the
API published on it; Client passes its cached network, eero and device envelopes as parent
automatically.
Error handling
use ;
match client.get_network.await
Error::error_code() is meta.error as the API sent it; Error::envelope() is the raw parsed
response; Error::status() the HTTP status when one applies. Messages are fixed, leak-safe labels.
๐ Raw Response Format
All API methods return the exact JSON from Eero's API, wrapped in a lossless Envelope:
env.meta(), env.data(), env.into_value() and env.data_as::<T>() are the only helpers.
๐๏ธ Features
| Feature | Default | Effect |
|---|---|---|
keyring |
on | Enables KeyringStore, backed by the OS keyring (macOS Keychain, Secret Service, Windows Credential Manager) |
๐ Docs
| Guide | What's inside |
|---|---|
| ๐ Rust API | Layers, builder options, every domain accessor, caching, errors |
| โ๏ธ Configuration | Sessions, credential stores, transport options, logging |
| ๐ง Troubleshooting | 401s, premium gating, validation errors, writes that change nothing |
| ๐ Migration | Upgrading from rusteero 1.0.0 |
| ๐ Wiki Home | All documentation |
| โ Parity checklist | Method-by-method status against eero-api |
๐ Ecosystem
| Project | Description |
|---|---|
| ๐ eero-api | The Python library this crate is a port of |
| ๐ฅ๏ธ eeroctl | Terminal interface for Eero networks (Python) |
| ๐ eero-ui | Svelte dashboard for network management |
| ๐ eero-prometheus-exporter | Prometheus metrics for monitoring |
๐ Acknowledgments
rusteero is a Rust client library for the Eero (Amazon) mesh Wi-Fi cloud API, ported from
eero-api. No code was copied from it or from any
other project; full lineage and licence attribution is in NOTICE, and the long-form
version with what changed in the port is on the
wiki.
โ ๏ธ Important Notes
Unofficial Project: This library uses reverse-engineered APIs and is not affiliated with or endorsed by Eero or Amazon.
Amazon Login Limitation: If your Eero account uses Amazon for login, this library may not work directly due to API limitations. Workaround: Have someone in your household create a standard Eero account (with email/password) and invite them as an admin to your network. Then use those credentials to authenticate.
๐ License
MIT โ Use it, fork it, build cool stuff ๐