eero-api

Async Rust client library for the eero WiFi router API.

This crate provides a typed, async client for interacting with eero mesh WiFi routers. It covers:

• Authentication (login/verify flow)
• Network management and settings
• eero node control (LED, nightlight, reboot)
• Connected device tracking and management
• Profiles (parental controls)
• Port forwarding rules
• Activity monitoring (requires eero Plus)
• Diagnostics and speed tests
• Guest network management

Quick Start

use eero_api::{EeroClient, InMemoryStore, ClientBuilder};

#[tokio::main]
async fn main() -> eero_api::Result<()> {
    // Create a client with an in-memory credential store
    let store = InMemoryStore::new();
    let client = ClientBuilder::new()
        .credential_store(Box::new(store))
        .build()?;

    // Authenticate with a known session token
    client.credentials().set_session_token("your_token").await?;

    // List networks on the account
    let account = client.get_account().await?;
    for net in &account.networks.data {
        println!("{}: {}", net.url, net.name.as_deref().unwrap_or("unnamed"));
    }

    // Get devices on the first network
    let network_id = 12345;
    let devices = client.get_devices(network_id).await?;
    for device in &devices {
        println!("{}", device.display_name.as_deref().unwrap_or("unknown"));
    }

    Ok(())
}

Authentication

The eero API uses a two-step verification flow:

// Step 1: Send verification code to email or phone
client.login("you@example.com").await?;

// Step 2: Verify with the code (stores session token automatically)
client.verify("123456").await?;

// Now authenticated — session token is persisted in the credential store
let account = client.get_account().await?;

Credential Backends

Session tokens are stored via the CredentialStore trait. Multiple backends are available:

Enable optional backends in your Cargo.toml:

[dependencies]
eero-api = { version = "0.1", features = ["keyring"] }

API Methods

Account

Networks

Speed Tests

Guest Network

eero Nodes

Devices

Profiles

Port Forwarding

Activity

Diagnostics

Type System

All API response types are in the eero_api::types module. Types use #[serde(flatten)] with a HashMap<String, Value> extra field for forward compatibility — unknown fields from the API are preserved rather than silently dropped.

Update types (e.g., NetworkUpdate, EeroUpdate, DeviceUpdate) use Option fields with #[serde(skip_serializing_if = "Option::is_none")] so only explicitly set fields are sent to the API.

Error Handling

All API methods return eero_api::Result<T>, which uses the eero_api::Error enum:

use eero_api::Error;

match client.get_account().await {
    Ok(account) => println!("{}", account.email.display_name),
    Err(Error::NotAuthenticated) => eprintln!("Please log in first"),
    Err(Error::Api { code, message }) => eprintln!("API error {code}: {message}"),
    Err(e) => eprintln!("Error: {e}"),
}

License

MIT — see LICENSE.