Sign in Start free
Apache-2.0 core · edge to cloud

every device is an actor

Message it, query it, script it — without building IoT infrastructure.

iot.actor is an open-source, actor-based backend for IoT. Every sensor or device becomes a live digital-twin actor with state, a mailbox, an event log and behavior — hosted for you, or self-hosted anywhere.

Start free Talk to sales

Free for 50 devices and 1M messages a month. Run the whole runtime locally with iotactor dev.

Built on open foundations
Apache Pekko Streambed WebAssembly MQTT 5 Postgres Parquet
The problem

Your IoT backend is nine services. It should be one.

A connected product needs a broker, a registry, a shadow store, a time-series database, a rules engine, an offline queue and a pile of functions. Most teams spend 6–12 months on that plumbing before shipping a single feature — and then the cloud vendor deprecates half of it.

01ConnectivityBroker, TLS, X.509 and token auth
02Device registryIdentity, metadata, provisioning
03State and shadowReported vs. desired, conflicts
04Offline handlingQueue while asleep, replay on reconnect
05HistoryTime-series, retention, downsampling
06LogicRules, alerts, schedules
07Fleet opsGroups, bulk commands, OTA
08APIsFor apps, dashboards, integrations
09Observability“Why did #4471 do that at 03:12?”
= 1One device actorAll of the above, per device

iot.actor replaces that stack with one primitive borrowed from Erlang, Akka and Orleans: the actor. You write thermostat.send("setTarget", 21) and the platform handles delivery, persistence, retries and history.

The device actor

A live digital twin with a stable address

Every device — or logical thing, like a room, a truck or a site — is an actor you can message, query and script. Actors compose into hierarchies: organisation, fleet, site, room, device.

actor://acme/fleet-eu/site-istanbul-01/fridge-07

Identity

Who it is

Unique ID, X.509 or token credentials, type, tags and metadata.

State

Reported, desired, derived

What the device says, what your apps want, and what your behavior computes.

Mailbox

Commands that wait

An ordered, durable inbox. Commands queue while the device is offline and are delivered on reconnect, with TTL and priority.

Event log

Every message, kept

An append-only, event-sourced history of every message, state change and decision.

Behavior

Your code, sandboxed

TypeScript, Python, Rust or Go compiled to WASM. Reacts to messages, timers and other actors.

Timers

Durable schedules

“If no heartbeat in 10 min, raise an alarm” — and it survives restarts.

Lifecycle

Always addressable

Activated on demand, passivated when idle. You pay almost nothing for sleeping devices.

Supervision

Failures stay small

Behavior errors are isolated, retried and reported. One bad device can’t take down the fleet.

Developer experience

First device online and scripted in under 10 minutes

Firmware publishes and receives. Apps get state, history and a websocket. We handle everything after the radio.

  1. 1
    Define a device type and its behavior
    Plain TypeScript, compiled to WASM. Runs identically on the gateway and in the cloud.
  2. 2
    Connect the device
    Three calls in C on ESP-IDF, Zephyr or FreeRTOS. The SDK buffers readings and replays exactly once.
  3. 3
    Talk to it from anywhere
    CLI, REST, WebSocket, SQL fleet queries and language SDKs.
SDKs · C and Python first
C · ESP-IDF Zephyr FreeRTOS MicroPython Arduino Rust Go Python TypeScript Swift · Kotlin
Local dev server
The whole runtime on a laptop
Simulator
10,000 virtual devices for load tests
Templates
Cold-chain, smart meter, EV charger
GitOps
Terraform provider, fleets as code
fridge.tsbehavior → wasm
import { actor } from "@iotactor/sdk";

export const Fridge = actor("fridge", {
  state: { temp: 0, door: "closed", alarm: false },

  on: {
    // telemetry from the device
    reading(ctx, msg) {
      ctx.state.temp = msg.temp;
      if (msg.temp > 5) ctx.timer.start("tooWarm", "15m");
      else ctx.timer.cancel("tooWarm");
    },
    // command from an app — queued if offline
    setTarget(ctx, msg) { ctx.device.send("setTarget", msg); },
  },

  timers: {
    tooWarm(ctx) {
      ctx.emit("alert", { level: "critical",
        text: `Fridge at ${ctx.state.temp} °C for 15 min` });
      ctx.parent.send("childAlarm", { id: ctx.id });
    },
  },
});
main.c · esp-idf
iotactor_client_t *c = iotactor_connect("fridge-07", CERT, KEY);
iotactor_send(c, "reading", "{\"temp\":4.2,\"door\":\"closed\"}");
iotactor_on(c, "setTarget", handle_set_target); // queued commands
fridge-07 · 2026-10-29 UTC
Event history and time travel

Rewind any device to any moment

Every actor is event-sourced, so “why did the fridge alarm at 03:11?” has an exact answer.

  • Query state as of any timestamp. Point lookups, SQL over current state and history, live subscriptions.
  • Replay history through new code. See what a new alert rule would have flagged last month — before you ship it.
  • Scrub the inspector like a video. Step through events, mailbox and timers on one timeline.
Offline-first, edge to cloud

The same actor on the gateway and in the cloud

Same ID, same WASM behavior, same event log. Automations keep running when the internet doesn’t, then the gateway syncs its history upstream.

Edge runtime

Rust on Streambed

One small binary for gateways and routers: x86, ARM64, ARMv7 and MIPS32.

  • Local MQTT broker, BLE, Modbus, serial, LoRa
  • Commit log and secret store on the device
  • WASM via wasmtime, or wasmi on small CPUs
  • Signed OTA self-update, local inspector
Edge ⇄ cloud

Edge Sync Protocol

An open, versioned protobuf spec published in the repo.

  • Edge-initiated: works behind NAT and firewalls
  • Sequence-numbered per-actor streams
  • Resumes from the last acknowledged offset
  • gRPC or MQTT 5 over mTLS
Cloud runtime

Apache Pekko, Scala 3

Battle-tested, ASF-governed actor infrastructure — clustering we didn’t have to invent.

  • Cluster Sharding: one entity per device
  • Persistence on Postgres, then Cassandra or ScyllaDB
  • History as Parquet, queried with SQL
  • REST, WebSocket, gRPC and MCP
Edge footprint targets
Hardware Example Memory budget Actors
Small routerOpenWrt MIPS32 / ARMv7, 128 MiB≤ 16 MiB500
Standard gatewayRaspberry Pi 4/5, industrial ARM64≤ 64 MiB10,000
Site serverx86 mini PC≤ 256 MiB100,000
Delivery guarantees

No lost commands. No double-counted readings.

device → actorEffectively exactly-onceAt-least-once delivery with sequence-ID deduplication.
actor → deviceDurable mailboxTTL, priority, required acks, retry with backoff.
actor → actorOrderedIn-cluster ordering per sender and receiver pair.
behaviorsDeterministicPure over the event log, so replay is exact.
50Mactors per cluster
200kmessages per second, per node
< 20 msP99 cloud-side latency
99.9 %uptime SLA, cloud

Design targets for general availability, not benchmark results. Passivated actors use no memory.

Enterprise

Self-host, audit everything, keep data in-region

Run it in our cloud, a dedicated cluster, or your own data centre — air-gapped if you need to.

Request a security review

Device identity

Per-device X.509, just-in-time provisioning, certificate rotation, claim tokens.

Tenant isolation

WASM sandbox and per-tenant quotas at runtime; row-level or dedicated clusters for storage.

Access policies

RBAC and attribute policies for who can read or command which actors — with separate policies for AI agents.

Tamper-evident audit

Who, what, when and why for every command, on a hash chain.

Encryption

TLS 1.3 in transit, encrypted at rest on cloud and edge, bring your own key.

Data residency

Region-pinned tenants in EU-Frankfurt, US-East and Istanbul for KVKK-sensitive data.

Single sign-on

SSO with SAML, SCIM provisioning, advanced RBAC.

Compliance packs

HACCP temperature reports and GxP audit trails, generated from the event log.

Compliance roadmap SOC 2 Type I SOC 2 Type II ISO 27001 EU Cyber Resilience Act alignment
AI-native · MCP

Give AI agents a safe handle on the physical world

A built-in MCP server exposes actors as typed, permissioned tools. Agents read state and history; commands they propose wait for a human to approve.

AgentWhich freezers in Istanbul were above −15 °C last night?
Tool
site-istanbul-01/freezer-02 · −12.8 °C · 41 min
QueuesetTarget −20 proposed — awaiting approval
Migration

AWS IoT Events support ended on 20 May 2026

Detector models map one-to-one to actor behaviors. Convert your detector-model JSON and move in a day — onto a core you can self-host if any vendor, us included, goes away.

  • AWS IoT Analytics — support ended 15 Dec 2025
  • Google Cloud IoT Core — shut down in 2023
  • IBM Watson IoT Platform — sunset Dec 2023
Read the migration guide
Use cases

Built for long-lived, stateful things

Cold chain and food safety

Per-fridge timers and alarms, HACCP audit trails, sites that stay safe offline. For restaurants, hotels, catering and pharma.

fridgefreezersitedelivery-truck

Smart buildings

Building, floor and room hierarchies with schedules and aggregate health.

roomhvac-unitmeter

Energy and EV charging

Stateful charging sessions, an OCPP bridge, and chargers that keep working offline.

chargersessioninverter

Agritech and greenhouses

Remote sites with flaky links: the gateway decides locally and syncs later.

greenhousevalvesoil-sensor

Asset tracking

Location as state, geofence timers, full movement history.

trackerpalletvehicle

Connected products

Hardware teams with 100 to 100,000 devices who would rather ship features than plumbing.

thermostatsmart-meterany
Open Core Pledge

Apache-2.0, forever

We keep the core Apache-2.0 — no relicensing — and plan to move it to a neutral foundation once the community is contributing. When Akka was relicensed, its community forked it into Apache Pekko. We build on that lesson, and on Pekko itself.

Star on GitHub Read the pledge

Open source

Apache-2.0
  • Cloud actor runtime, single node and clustered
  • Edge runtime and Edge Sync Protocol spec
  • Device SDKs in every language
  • CLI, local dev server, simulator
  • Basic inspector UI
  • Postgres driver, MQTT, HTTP, WS, CoAP adapters

Commercial

Cloud · Enterprise
  • Zero-ops hosting, autoscaling, global regions
  • Long-term history and analytics tier
  • Hosted time-travel debugger for teams
  • MCP agent gateway with approvals
  • Fleet OTA orchestration
  • Multi-region replication, 24/7 support
Pricing

Free to start, cheap to idle

Priced on active devices and messages, not seats. Sleeping devices passivate and cost almost nothing. Spend caps and no surprise egress fees.

Hobby

$0
for side projects
  • 50 devices
  • 1M messages / month
  • 7-day history
  • Community support
Start free

Developer

$29 /mo
for your first product
  • 500 devices
  • 10M messages / month
  • 30-day history
  • 2 environments
Choose Developer

Team

Most teams
$299 /mo
for fleets in production
  • 5,000 devices
  • 100M messages / month
  • 1-year history
  • Alerts and SSO-lite
  • 3+ seats
Choose Team

Scale

Usage
pay for what runs
  • $0.04 per active device / month
  • $0.30 per million messages
  • $0.02 per GB-month of history
Estimate your bill

Enterprise

$40k /yr+
self-hosted or dedicated
  • Self-hosted or dedicated cloud
  • SLA and 24/7 support
  • SSO, SCIM, BYOK
  • Compliance packs
Talk to sales
Quickstart

Your fridge has an inbox now.

Start on the free tier, or run everything on your laptop first. Ship six months sooner, with no lock-in.

Start free Book a demo