Open source · Self-host free · Macintosh + Windows

See every endpoint.
Own all of the data.

ReportMate is open-source endpoint intelligence for Macintosh and Windows. Native clients do the heavy collection and processing on each device, then stream events to an API and database you control — no agents phoning home to a vendor.

Explore the Live Demo View on GitHub

Deploy to your own Azure or AWS tenant with Terraform — or let us run it for you.

Data modules per device

First-class platforms: Macintosh & Windows

40+

Versioned REST API endpoints

100%

Open source and self-hostable

Unified telemetry

Ten reports on every device.
The same on Macintosh and Windows.

Every check-in refreshes ten module reports, built and normalized on the endpoint to one shared schema. Not two tools bolted together — one genuinely unified fleet view.

Inventory

Asset tag, assigned owner, department, location, device name, manufacturer, purchase metadata.

Installs

Managed software from Cimian and Munki: target vs installed version, pending, installed, failed, logs.

Applications

Installed apps, versions, bundle IDs / product codes, publishers, install dates — Macintosh and Windows.

System

OS build & patch level, uptime, boot time, kernel, architecture, rapid security responses, locale.

Management

MDM enrollment & vendor, supervision, configuration profiles, certificates, managed status.

Identity

Logged-in user, local & directory accounts, home directory, Entra/AD join, shared-device state.

Hardware

Model & SoC, performance/efficiency cores, Neural Engine, GPU, RAM with per-module make, storage, battery health.

Peripherals

Displays, printers, USB and Bluetooth devices — resolution, drivers, default, connection type.

Security

FileVault / BitLocker, firewall, SIP, Gatekeeper, secure boot, TPM, XProtect, EDR presence.

Network

Interfaces, IPv4/IPv6, MAC, DNS, gateways, Wi-Fi SSID with band/channel/width, signal, VPN.

See every field each module collects →

A closer look

From fleet overview to a single chip

Start at the fleet level, then drill into any device for all ten modules — hardware down to the SoC, security posture, network, managed installs, and more.

ReportMate device hardware view showing CPU, memory, storage, battery, GPU and NPU

Event-driven & API-first

If the dashboard can show it, your code can fetch it

ReportMate is built API-first on FastAPI with a full OpenAPI specification. Devices ingest through the same documented event API the dashboard reads from. Query a single device, pull bulk fleet analytics, stream events, or wire ReportMate into your CMDB, SIEM, or automation.

40+ versioned /api/v1 endpoints with interactive OpenAPI docs
Per-device and bulk fleet queries: hardware, applications, installs, identity, inventory
Real-time event ingestion and a SignalR/WebSocket negotiate endpoint for live updates

Browse the API reference

$ curl https://api.reportmate.app/api/v1/devices \
    -H "X-Client-Passphrase: $RM_KEY"

{
  "devices": [
    {
      "serialNumber": "C02XL0ABJGH7",
      "deviceId": "9f2a1c7e-4b30-4d2a-bf1e-7c0a2d51e8a4",
      "name": "design-studio-04",
      "platform": "Macintosh",
      "osName": "Macintosh",
      "osVersion": "15.5",
      "assetTag": "ECU-04821",
      "department": "Design",
      "status": "active",
      "lastSeen": "2026-06-18T17:42:11Z",
      "totalEvents": 1284
    }
  ],
  "total": 327,
  "hasMore": false
}

End-to-end & self-hosted

Own the whole pipeline, end to end

The entire stack — native binaries, event-driven API, JSONB store, real-time push — deploys into your own Azure or AWS tenant with Terraform, in an afternoon. No per-layer vendors to license, every layer yours to audit and extend, and your fleet data never leaves infrastructure you control.

1

Collect
On device
Native binary reads OS-level data
2

Transmit
On device
Event sent over HTTPS
3

Ingest
In your cloud
FastAPI receives the event
4

Store
In your cloud
Written to PostgreSQL as JSONB
5

Read
Web & native
Dashboard, native apps & API

flowchart TB
  subgraph EP["① &nbsp;ENDPOINTS — collect &amp; process on-device"]
    direction LR
    MAC["<b>Macintosh</b><br/>native ReportMate binary<br/><small>Swift · launchd</small>"]
    WIN["<b>Windows</b><br/>native ReportMate binary<br/><small>C# / .NET · service + task</small>"]
    MAC ~~~ WIN
  end

  PAY{{"<b>one event payload</b><br/>10 module documents<br/><small>hardware · system · network · security · applications<br/>installs · inventory · management · identity · peripherals</small>"}}
  EP ==> PAY

  subgraph CLOUD["② &nbsp;YOUR CLOUD — Terraform on Azure/AWS, or self-host with Docker"]
    direction LR
    API["<b>FastAPI</b><br/>ingest + REST /api/v1<br/><small>40+ endpoints · OpenAPI</small>"]
    DB[("<b>PostgreSQL</b><br/>JSONB per module")]
    RT(["<b>SignalR / Web PubSub</b><br/>real-time push"])
    API --> DB
    API --> RT
  end
  PAY ==>|"HTTPS POST /api/v1/events<br/>X-Client-Passphrase"| API

  subgraph READ["③ &nbsp;READ — web, native &amp; your tools"]
    direction LR
    WEB["<b>Next.js dashboard</b><br/><small>live fleet view</small>"]
    APPS["<b>Native Macintosh &amp; Windows apps</b><br/><small>coming soon</small>"]
    INT["<b>CMDB · SIEM · automation</b><br/><small>via REST API</small>"]
  end
  DB ==> WEB
  RT ==> WEB
  DB ==> APPS
  RT ==> APPS
  API ==> INT

  classDef ep fill:#eff6ff,stroke:#2563eb,stroke-width:2px,color:#1e3a8a;
  classDef pay fill:#0074c7,stroke:#015da1,stroke-width:2.5px,color:#ffffff;
  classDef cloud fill:#ecfdf5,stroke:#059669,stroke-width:2px,color:#065f46;
  classDef read fill:#fff7ed,stroke:#ea580c,stroke-width:2px,color:#9a3412;
  class MAC,WIN ep;
  class PAY pay;
  class API,DB,RT cloud;
  class WEB,APPS,INT read;

  style EP fill:#f8fafc,stroke:#cbd5e1,color:#334155;
  style CLOUD fill:#f8fafc,stroke:#cbd5e1,color:#334155;
  style READ fill:#f8fafc,stroke:#cbd5e1,color:#334155;

Collection and processing run on the endpoint; storage, real-time push, and reading run in infrastructure you own.

Engineering principle

The right tool at every layer

A deliberate split: a compiled native binary where reliability matters most, Python and FastAPI where iteration speed and ecosystem matter most. Each layer gets the tooling it deserves.

On the device

A single compiled binary that just runs

Collection is Swift on Macintosh and C#/.NET on Windows, driven by osquery and native OS tooling. A self-contained binary installs in seconds and runs unattended — built for the kind of rock-solid reliability fleet collection demands, day after day, with nothing to babysit.

Swift (Macintosh) and C#/.NET (Windows)
osquery + native OS APIs for fast, accurate collection
One self-contained binary — quick to deploy, nothing to maintain

In your cloud

Python & FastAPI, where they shine

The API layer is exactly where Python pays off: FastAPI gives us a typed, OpenAPI-documented event API that's fast to extend and a pleasure to integrate against. Its rich ecosystem lives in the cloud you control and upgrade on your own schedule.

FastAPI with a full OpenAPI spec and interactive docs
Runs in a container, provisioned by Terraform on Azure or AWS
Upgraded centrally — endpoints are unaffected

Built for teams that want control

Truly cross-platform

One schema, one dashboard, one API for Macintosh and Windows. No reconciling two products with different data models and different bills.

Your data, your cloud

Self-host or deploy to your own Azure/AWS tenant with the included Terraform. Telemetry never transits a vendor's servers. Encrypted in transit, passphrase-authenticated.

Open source, no lock-in

Source-available under BSL 1.1. Read the code, audit the collection, extend a module, or fork it. Your data lives in plain PostgreSQL you can query directly.

Built on open source

ReportMate stands on the shoulders of the tools our community already trusts — and integrates with the managed-software systems you may already run.

osquery

The SQL-powered engine behind on-device collection.

FastAPI

Powers the event ingest and REST API.

Next.js

Renders the real-time fleet dashboard.

PostgreSQL

JSONB storage — one document per module.

Terraform

Provisions ReportMate into Azure or AWS.

Munki

Macintosh managed installs, surfaced in the Installs module.

Cimian

Windows managed installs, surfaced in the Installs module.

Ready to take control of your fleet?

Click around the live demo, or deploy your own in an afternoon. Self-host for free, or let us run it.

Explore the Live Demo See Pricing

See every endpoint. Own all of the data.

Ten reports on every device. The same on Macintosh and Windows.