Prometheus metrics

Scrape the device's host and Pinna metrics with Prometheus from the /metrics address.

The device serves metrics in the Prometheus text format at /metrics, on the same port as the dashboard. They show how the device is doing (CPU, memory, temperature, Wi-Fi, its services) and how Pinna is doing (wakes, requests, reply times, Home Assistant’s connection, and in standalone mode how much you use your services).

Use them if you run Prometheus or a program that reads its format. Home Assistant doesn’t need them.

Scrape the device

Add a job to prometheus.yml with the device’s IP address. Reserve that address for the device in your router, so that it doesn’t change:

scrape_configs:
  - job_name: pinna
    static_configs:
      - targets: ["192.168.1.40:80"]

A .local name such as pinna-2a914e.local works only if the machine that runs Prometheus resolves .local names. Prometheus’s own builds and its Docker image don’t.

To check the address, open http://192.168.1.40/metrics in a browser. With a dashboard password set, the browser gets 401. Run this on your computer instead, with the metrics token:

curl -H "Authorization: Bearer TOKEN" http://192.168.1.40/metrics

Then, in Prometheus, open Status > Targets: the pinna job shows UP.

The device answers only to the names the dashboard answers to, such as its IP addresses and .local names. If you scrape it by another DNS name, add that name first, as in Set a dashboard address, or the device answers 421 Misdirected Request.

A scrape every 15 to 60 seconds is fine. The device reads the numbers when it’s scraped.

Host metrics

The host metrics have the names and labels that node_exporter uses, so Grafana’s node_exporter dashboards, such as Node Exporter Full, show them. Node Exporter Full shows uptime, CPU, load, memory, pressure, network and file systems. Its disk I/O, context switch and other detailed panels stay empty: the device doesn’t serve those metrics.

Metric What it is
node_uname_info Kernel version and host name
node_time_seconds, node_boot_time_seconds The time now, and when the device started
node_cpu_seconds_total{cpu,mode} CPU time per core and mode
node_load1, node_load5, node_load15 Load average
node_memory_*_bytes MemTotal, MemFree, MemAvailable, Buffers, Cached, SwapTotal, SwapFree
node_pressure_*_seconds_total Time tasks waited for CPU, memory or storage
node_filesystem_size_bytes, node_filesystem_avail_bytes Size and free space of each file system on the storage
node_network_{receive,transmit}_{bytes,errs,drop}_total{device} Traffic, errors and dropped packets per network interface
node_thermal_zone_temp{zone,type} Temperature of each thermal zone, in °C
pinna_wifi_signal_dbm{device} Wi-Fi signal level. Missing while not connected
pinna_unit_memory_bytes{unit} Memory each system service uses
pinna_unit_memory_max_bytes{unit} A service’s memory limit, if it has one
pinna_unit_cpu_seconds_total{unit} CPU time each service used
pinna_unit_oom_kills_total{unit} Times the kernel stopped a service’s process because memory ran out: the service’s own limit, or the device’s
process_* Memory, CPU time, threads and open files of pinnad itself

Pinna metrics

Counters start at 0 when pinnad starts. Those with a label, such as word or code, appear once they first count something.

Metric What it is
pinna_build_info{version,model,slot} The running version, the device model and the A/B slot
pinna_last_boot_info{outcome} How the boot before this one ended: clean (a restart), cold (power cut or first start), crashed (a kernel crash), reset (stopped without shutting down) or rescue (ended in rescue mode)
pinna_home_assistant_connected 1 while Home Assistant is connected
pinna_voice_subscribed 1 while Home Assistant takes voice requests from the device
pinna_wake_word_enabled 1 while the wake word is on and at least one wake word is chosen
pinna_microphone_muted{switch} 1 while the microphones are off, by the hardware button or the software switch
pinna_timers{state} Timers that are running or paused
pinna_alarm_ringing 1 while a timer alarm rings
pinna_airplay_state{state}, pinna_bluetooth_state{state} 1 for the current state: off, starting, ready, failed or unavailable
pinna_bluetooth_paired_devices Phones paired over Bluetooth
pinna_wakes_total{word} Wake word detections, per wake word ID, such as alexa_v0.1
pinna_wake_near_misses_total Sounds that almost woke the device
pinna_assist_runs_total Voice requests started, in either mode. In standalone mode, a question typed on the dashboard counts too, and a follow-up counts once it hears speech
pinna_assist_errors_total{code} Voice requests that Home Assistant ended with an error, by its error code, such as stt-no-text-recognized or intent-failed. Other codes count as other. Failed standalone requests count in pinna_standalone_errors_total instead
pinna_reply_first_audio_seconds Histogram of the time from the end of your speech to the first sound of the reply, in either mode, in buckets from 0.25 to 13 seconds
pinna_speaker_underruns_total Times the speaker ran out of sound and restarted, which can click

For example, wakes in the last hour, and the time 9 replies in 10 take to start:

increase(pinna_wakes_total[1h])
histogram_quantile(0.9, sum by (le) (rate(pinna_reply_first_audio_seconds_bucket[1h])))

Standalone mode

These metrics describe standalone mode. The gauges are there in either mode.

Metric What it is
pinna_standalone_mode 1 while the device runs in standalone mode
pinna_standalone_slot_ready{slot} 1 while a slot is set up and has passed its check: stt (speech-to-text), brain or tts (text-to-speech)
pinna_standalone_errors_total{slot,reason} Standalone requests that failed. slot is stt, brain, tts or tool. reason is the HTTP status (http_401, http_402, http_403, http_404, http_429, http_3xx, http_4xx, http_5xx or http_other), timeout, unreachable, tls, clock (the device’s clock wasn’t set), protocol (an answer the device couldn’t read), too_large or internal
pinna_standalone_stage_seconds{slot} Histogram of the time each stage took: stt to the transcript, brain to the brain’s first text, tts to text-to-speech’s first audio. Buckets from 0.25 to 120 seconds
pinna_standalone_audio_seconds_total{preset} Seconds of speech sent to speech-to-text
pinna_standalone_tokens_total{preset,direction} Tokens that the brain’s service reports it read (input) and wrote (output)
pinna_standalone_characters_total{preset} Characters sent to text-to-speech
pinna_standalone_guards_total{guard} Times a guard against spending acted: no_speech (a request or follow-up heard no speech, so nothing was uploaded), invented (a transcript that speech-to-text invents on silence was dropped), follow_up (a follow-up heard speech), ack (a slow agent’s acknowledgment played), stopped_by_wake and stopped_by_button (the wake word or the Action button stopped a request)
pinna_tool_calls_total{tool,outcome,via} Tool calls. tool is the device tool’s name, such as set_timer; for a tool of one of your MCP servers, the server’s name; and other for any other name. outcome is ok or error. via is brain (the brain’s tool loop), mcp (a client of the device’s MCP server) or peer (another satellite of its satellite group, for its brain)
pinna_mic_frames_dropped_total Microphone frames that a standalone request didn’t take in time

preset is the preset of the connection that served the slot: openai, openrouter, anthropic, gemini, groq, mistral, elevenlabs, ollama, lmstudio, hermes, openclaw, or custom for an address you entered in full.

No label carries an address, a key, what was said, or a name that an MCP client sends. Each label value comes from a fixed list, or is the name of one of your MCP servers (at most 8), so a device on your network can’t add series.

For example, the tokens each service used in the last day, and the standalone requests that failed, by slot and reason:

increase(pinna_standalone_tokens_total[1d])
sum by (slot, reason) (increase(pinna_standalone_errors_total[1d]))

Sendspin

These metrics describe the Sendspin player, and show whether it keeps time with its group. They are there whether Sendspin is on or off.

Metric What it is
pinna_sendspin_state{state} 1 for the current state: off, ready (listening, with no server connected), connected (a server is connected), failed or unavailable. There is no playing state, so that the metric doesn’t record when music played
pinna_sendspin_sync_error_seconds How much later the stream sounds than the server’s clock says it should; negative when it sounds early. Missing while no stream sounds
pinna_sendspin_clock_error_seconds The standard deviation of the clock filter’s estimate of the server’s clock. Missing while no server is connected, and until the filter’s first measurement
pinna_sendspin_steady 1 while a stream plays and 10 seconds or more have passed since its start or its last jump, clear, underrun or error above 1 ms
pinna_sendspin_jumps_total Times a stream started at the right sample instead of correcting its speed: at its start, and after a clear, an underrun or an error too large to correct
pinna_sendspin_late_drops_total Audio chunks dropped because they arrived after their time
pinna_sendspin_decode_errors_total Audio chunks dropped because they didn’t decode

The sync error shows how closely the satellite follows its own idea of when a sample sounds. It can’t show a fixed error in that idea, such as the delay of the speaker’s own path, which isn’t measured yet.

The pinna_* names can change before Pinna 1.0. The release notes say when one does. The node_* names follow node_exporter.

Who can read them

Without a dashboard password, anyone on your network can read /metrics, including how often the wake word fired and, in standalone mode, which services you use and how much. It doesn’t show what was said, or whether a request is running. It has no switch of its own: it is off only when the dashboard is off, which is a developer setting.

Once you set a password, /metrics needs the metrics token, which opens nothing else. On the dashboard, open System > Password and tokens, and under Tokens select Create a token next to Metrics token. Copy the token at once: the dashboard shows it only then, and keeps only its last four characters. Give it to Prometheus as authorization credentials, which it sends as Authorization: Bearer <token>:

scrape_configs:
  - job_name: pinna
    static_configs:
      - targets: ["192.168.1.40:80"]
    authorization:
      credentials: "<token>"

Prometheus also reads the token from a file, with credentials_file. A new token replaces the old one, which stops working at once, so put the new one in Prometheus’s configuration right away. Without the token, the device answers 401. If a scrape shows DOWN after you set a password, that is the reason.

Edit this page on GitHub