Troubliq

Smart-home fixes, step by step.

Category: Devices & Integrations

Smart-home device discovery, account linking, permissions, compatibility, firmware, integrations, and unavailable-device troubleshooting.

  • UniFi Protect unavailable in Home Assistant: authentication, API mode, streams, and NvrError fixes

    UniFi Protect unavailable in Home Assistant: authentication, API mode, streams, and NvrError fixes

    Direct answer: When UniFi Protect is unavailable in Home Assistant, start by confirming that Protect is running on a supported UniFi OS Console, that the console is reachable by its local IP address, and that Protect is on the Stable release channel at version 7.2.105 or later. Then verify the connection mode: full access requires both a local-only UniFi OS user and an API key, while API-key-only mode intentionally exposes fewer entity types and no media source, actions, or proxy views. Do not delete the integration, rotate every credential, or reset cameras until you have identified whether the failure is authentication, permissions, routing, stream availability, or an unsupported Protect installation.

    Symptoms and exact scope

    This guide covers the official Home Assistant UniFi Protect integration connected to Protect running on a UniFi OS Console. It does not cover self-hosted or containerized Protect installations, which Ubiquiti does not officially offer and Home Assistant does not support. Common symptoms include the entire integration showing unavailable, cameras appearing without live video, only camera and light entities being present, event or sensor entities disappearing, media browser folders missing, repeated authentication failures, delayed video, and log messages containing NvrError with 404 - Reason: Not Found or 502 - Reason: Bad Gateway.

    Record the Home Assistant version, UniFi OS version, Protect version, console model, camera models, connection mode, console IP address, and the time the problem began. If the failure followed an upgrade, record whether the console was on Stable, Release Candidate, or Early Access. This information separates an ordinary configuration problem from an unsupported release-channel regression.

    Before changing anything

    Confirm that recordings and live views work inside the local UniFi Protect application. If Protect itself cannot display cameras, Home Assistant is downstream of the real failure. Check storage warnings, console utilization, camera adoption status, and whether Protect is still starting. Avoid rebooting the console during an active firmware update or while storage repair is in progress.

    Safety and privacy: Camera feeds, event thumbnails, doorbell images, fingerprints, NFC identifiers, access logs, local IP addresses, API keys, and usernames are sensitive. Never paste an API key or an unredacted diagnostics archive into a public forum. Do not expose the UniFi console directly to the internet to make Home Assistant connect. Use local routing or a properly secured remote-access design instead.

    UniFi Protect failure matrix

    ObservationMost likely layerLeast-destructive next check
    All Protect entities unavailableConsole reachability, authentication, Protect service, or versionOpen the local console IP and confirm Protect is running
    Camera streams work but sensors and events are missingAPI-key-only mode or limited permissionsCheck the configured connection mode and user role
    Media source and notification proxy URLs are missingAPI-key-only modeReconfigure to full access if those features are required
    Live feed repeatedly refreshes snapshotsNo active RTSPS streamCheck the Home Assistant repair and Protect stream availability
    404 - Reason: Not FoundStale endpoint, Protect restart, proxy path, or API mismatchConfirm current stable versions and reload once after Protect is fully online
    502 - Reason: Bad GatewayProtect backend or proxy unavailableTest Protect locally and inspect console health before changing Home Assistant
    Alarm Manager entities disappearedProtect Alarm Manager switched to Global modeCheck whether sensors, relays, fobs, or an Alarm Hub were adopted
    Only some cameras or controls are missingUser permissions, device capability, or API-version supportCompare the local user role and camera capabilities

    1. Confirm supported hardware and software

    The official integration supports UniFi Protect only when it runs on a UniFi OS Console capable of running Protect. A container or third-party self-hosted installation may report an internal address in camera-stream URLs that Home Assistant cannot reach. That symptom cannot be repaired reliably by changing Home Assistant host fields because the unsupported Protect instance is advertising unusable endpoints.

    Home Assistant currently requires UniFi Protect 7.2.105 or later. Update an older installation through the supported UniFi OS interface, but do not move to Early Access or Release Candidate merely to obtain a newer number. Home Assistant explicitly does not support those prerelease channels, and they can change the API before the integration is ready.

    If a feature is absent rather than the whole integration failing, check whether the feature requires a newer Protect public API version. A camera can remain available while a recently added entity is missing. That is different from authentication failure and should not trigger credential resets.

    2. Test the console locally

    From the same trusted network as Home Assistant, open the console by its local IP address. Confirm that UniFi OS loads, Protect opens, cameras are adopted, and a live view plays. This tests the route without depending on the cloud portal. If only unifi.ui.com works, investigate local DNS, VLAN routing, firewall policy, or console networking.

    Compare the address stored in Home Assistant with the console’s current address. Reserve the console IP in the router rather than assigning an arbitrary static address inside the DHCP pool. If the address changed, use the integration’s Reconfigure flow instead of deleting the integration. Preserving the entry protects entity IDs used by automations and dashboards.

    If Home Assistant and the console are separated by VLANs, verify narrowly scoped local access. Do not open broad inbound internet rules. Record existing firewall rules before testing and restore them if a change does not help. A temporary same-subnet test can prove whether routing is the failing layer without permanently weakening segmentation.

    3. Understand full access versus API-key-only mode

    Full access is the recommended mode for most users. It requires a local-only UniFi OS user plus an API key. It provides the broad entity set, actions, media source, and proxy views used for notification thumbnails and video clips. API-key-only mode is intentionally limited: cameras provide streams and snapshots, lights are supported, and some NVR Alarm Manager functionality is available, but binary sensors, events, media players, many controls, actions, media source, and proxy views are not.

    If a reconfiguration from full access to API-key-only caused entities to become unavailable, that is expected behavior, not data corruption. Switch back through Settings → Devices & services → UniFi Protect → Reconfigure if those entities are needed. They should return when the required mode and permissions are restored.

    Do not create overlapping integration entries for each connection mode. Duplicate entries can create confusing device and entity sets without solving the underlying permission difference.

    4. Verify the local user correctly

    For full access, the account must be created in the console’s local portal, not as a Ubiquiti cloud SSO user. Open the console by IP, go to Admins & Users, add an administrator restricted to local access, and assign the Protect role appropriate to the functions Home Assistant needs. The official documentation recommends Full Management for the widest support, but a narrower role can be used if you accept fewer or read-only entities.

    A cloud account that works at unifi.ui.com does not satisfy this local-user requirement. Repeated login failures with a valid cloud password often point to the wrong account type rather than a bad password.

    After changing permissions, reconfigure or reload the existing integration. Verify that the expected entity domains return before changing anything else. If only one camera remains absent, inspect device-specific access and adoption rather than increasing the global role again.

    5. Validate the API key without exposing it

    Create the API key from Protect’s Integrations page while logged into the local portal as an administrator. Copy it once into the Home Assistant setup flow. Do not save it in screenshots, notes synchronized to public services, YAML examples, or support posts.

    If the key was revoked or rotated, reconfigure the existing integration with the replacement. Avoid deleting the entry because deletion can break dashboards, notification automations, and entity references. If compromise is suspected, revoke the old key after the replacement is confirmed, then review console access logs and Home Assistant diagnostics.

    An API key alone does not grant full-access features. If the entry was configured in full-access mode, both the local username/password and API key must be valid.

    6. Diagnose missing or delayed camera streams

    Home Assistant uses active RTSPS streams exposed by the Protect public API and selects the highest-quality active stream as the default feed. If no stream is active, Home Assistant may create a repair that can enable one. Until a stream exists, the camera feed can fall back to repeatedly refreshed snapshots, increasing console load and looking like a slow video connection.

    Open the camera in Protect and verify that it is online and streaming. Check Home Assistant Repairs for a stream-related item. Enable the required stream through the supported repair rather than copying obsolete RTSP URLs from old tutorials. Then reload the integration and test a single camera before changing all cameras.

    Video delay can also reflect transcoding, browser playback, network loss, or an overloaded console. Compare a local Protect live view with Home Assistant. If both are delayed, focus on the camera, console, storage, or network. If only Home Assistant is delayed, collect integration diagnostics and note the stream quality and client used.

    7. Interpret NvrError 404 and 502 safely

    A 404 - Reason: Not Found means a requested Protect resource or endpoint was not found. It can occur temporarily while Protect restarts, after an API path changes, or when a saved reference points to an event that no longer exists. A 502 - Reason: Bad Gateway indicates that the gateway could not obtain a valid response from the Protect backend. Neither message proves that the camera itself is defective.

    First verify that Protect is fully loaded locally. Wait for an intentional console or Protect restart to finish, then reload the integration once. Confirm Stable-channel versions and capture the exact log time, endpoint category, and affected camera. Do not loop reloads or console reboots; repeated reconnects can obscure the original failure and add load.

    If the error persists while Protect works locally, download Home Assistant diagnostics, redact secrets and local identifiers, and check the official integration issue tracker for the same Protect and Home Assistant versions. A concise report should include console model, Protect version, Home Assistant version, camera model, connection mode, exact error, reproduction steps, and whether local Protect playback works.

    8. Explain entities that disappear by design

    Some missing entities are expected consequences of settings. Smart-sensor functions that are disabled are marked unavailable. Alarm Manager and Alarm profile entities appear only when Protect Alarm Manager is in Local mode. Adopting sensors, relays, fobs, or an Alarm Hub can switch Alarm Manager to Global mode, where the public API does not expose arm profiles and Home Assistant cannot create those entities.

    Likewise, G3 cameras do not provide the smart detections documented for G4 and AI series cameras. Package detection is represented as an event entity rather than a sustained binary sensor. These capability differences should be checked before treating a missing entity as a regression.

    9. Verify recovery

    • The UniFi OS console opens through its local IP from the Home Assistant network.
    • Protect is on Stable version 7.2.105 or later and finishes loading normally.
    • The integration uses the intended full-access or API-key-only mode.
    • Full access uses a local-only user, not a cloud SSO account, plus a valid API key.
    • Expected cameras and supported sensors appear without duplicate integration entries.
    • An active RTSPS stream plays for one camera without snapshot-only fallback.
    • Media source, proxy views, actions, and events appear only when the selected mode supports them.
    • Logs remain free of recurring 404 or 502 NvrErrors after one normal reload.

    Rollback and recovery

    If a new API key fails, restore the previous working key if it has not been revoked. If changing to API-key-only removes needed entities, reconfigure to full access. If a VLAN test fails, restore the original firewall rules and network placement. If a Protect update caused the failure, do not attempt unsupported firmware downgrades without Ubiquiti guidance; preserve recordings and configuration, collect diagnostics, and wait for a supported stable fix.

    If the integration entry was deleted, recreate it with the same console and credentials, then repair automation references carefully. Restoring an entire Home Assistant backup is usually excessive for a credential or routing issue and may roll back unrelated changes.

    Prevention

    • Reserve the console’s local IP address.
    • Use a dedicated local-only account and a dedicated API key for Home Assistant.
    • Keep Protect and UniFi OS on Stable channels.
    • Record the console, Protect, Home Assistant, and camera versions before upgrades.
    • Export or verify backups before major console changes.
    • Review entity availability after changing connection mode, user role, Alarm Manager mode, or adopted security devices.
    • Keep API keys, event images, access logs, and diagnostics private.

    Related Troubliq guides

    Use the Device Unavailable Diagnostic when the failing network layer is unclear. The Smart-Home Diagnostic Decision Tree can separate authentication, routing, and device problems. For another camera integration workflow, compare the Reolink camera unavailable guide. If a reverse proxy produces an HTTP error before Home Assistant loads, use the Home Assistant 400 Bad Request reverse-proxy guide.

    Sources and review record

    Last reviewed: September 27, 2026. Testing disclosure: Troubliq synthesized current official documentation and documented integration behavior. We did not claim hands-on testing with every UniFi OS Console, camera model, firmware version, network design, or Protect release.

  • Roborock unavailable in Home Assistant: fix reauthentication and failed setup

    Roborock unavailable in Home Assistant: fix reauthentication and failed setup

    Direct answer: Start by checking whether the vacuum works in the official Roborock app and whether Home Assistant is asking for reauthentication. Temporary vacuum disconnects can make entities unavailable briefly, but repeated authentication prompts or “Failed to get Roborock home data” require a different path. Do not delete the integration first. Confirm account region, verification-code delivery, app authorization, network reachability, and logs; then reauthenticate the existing entry so entity identities are preserved.

    This guide addresses Roborock devices that are unavailable or repeatedly require reauthentication in Home Assistant. It is designed to preserve working configuration and evidence before any reset, deletion, or re-pairing. Work in order and stop when the first confirmed cause is corrected. Screens and menu labels can vary by Home Assistant release and installation method.

    Symptoms and scope

    Use the following signs to decide whether this guide matches your problem. Similar-looking failures can come from different layers, so record what still works as carefully as what fails.

    • All Roborock entities become unavailable while the official app still controls the vacuum.
    • Settings → Devices & Services shows Reconfigure or Reauthenticate for Roborock.
    • Setup fails after entering the emailed code, sometimes with “unexpected error” or “failed to get home data.”
    • The map stops updating while basic commands still work, or the integration recovers after the vacuum reconnects.
    • The problem returns every few hours or days despite successful reauthentication.

    Most likely causes, ranked

    Start with the causes that fit the evidence. Do not apply every fix at once: simultaneous changes make it impossible to know what solved the problem and can create a second failure.

    • 1. The vacuum briefly lost Wi-Fi or internet access; the official documentation notes short random disconnects can temporarily mark the integration unavailable.
    • 2. The Roborock account authorization or token is expired, revoked, region-mismatched, or replaced by another login flow.
    • 3. The verification code is delayed, expired, copied with whitespace, or issued for a different email/account region.
    • 4. DNS, firewall, ad-blocking, VLAN, or outbound filtering blocks the cloud endpoints needed for account and home-data discovery even when local communication later handles some commands.
    • 5. The vacuum is sleeping, rebooting, updating firmware, or associated with weak 2.4 GHz Wi-Fi.
    • 6. A Core or library regression affects a specific model or authentication flow; current logs and issue trackers are needed before destructive changes.

    Safe diagnostic procedure

    Before beginning, make a current backup when the procedure could affect configuration or stored data. Record the Home Assistant version, installation type, device or app version, the first failure time, and the last known working change. Redact secrets from every screenshot and log excerpt.

    Step 1: Capture the exact failure

    Confirm the official Roborock app can see and control the same vacuum using the same account. Note whether maps, rooms, status, and commands work. If the app also fails, fix the account, vacuum Wi-Fi, or Roborock service first; Home Assistant cannot repair a vendor-side outage.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 2: Protect the current state

    Open the Roborock device and integration pages in Home Assistant. Record the exact unavailable entities and any Repair, Reconfigure, or Reauthenticate prompt. Do not remove the device, rename entities, or reset the vacuum. Those actions erase useful evidence and can create duplicate entities later.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 3: Verify the affected layer

    Review Settings → System → Logs for entries from the Roborock integration around the first failure. Separate authentication, connection, home-data, map, and model-specific errors. Redact email addresses, tokens, map data, coordinates, and local/public IP addresses before sharing logs.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 4: Test the least-destructive cause

    If Home Assistant offers reauthentication, use it on the existing integration entry. Request one fresh code, use the newest code promptly, and avoid repeated requests that can invalidate earlier codes or trigger rate controls. Verify the selected account and region match the official app.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 5: Inspect configuration and identity

    Check whether another person, automation, password manager, or app session recently changed the Roborock password or revoked authorizations. In the official app, review account and third-party authorization controls. Revoke and recreate authorization only when the documented flow calls for it and you understand the effect.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 6: Check network, power, or permissions

    Test DNS and outbound connectivity from the Home Assistant host, not only from a phone on another network. Temporarily observe whether Pi-hole, AdGuard, firewall, parental controls, or VLAN policies log blocked Roborock requests. Do not permanently disable security controls; create the narrowest justified rule.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 7: Apply the narrow repair

    Check the vacuum’s Wi-Fi strength, DHCP lease, clock, and firmware status. Reserve a stable address if your network design benefits from it, but do not assume an IP reservation fixes cloud authentication. Reboot the vacuum and network only one component at a time so the result remains interpretable.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Step 8: Observe through a full cycle

    Update Home Assistant only after reading the release notes and making a backup. If the failure began immediately after an update and logs match a current upstream issue, preserve the configuration and follow the issue rather than repeatedly deleting and adding the integration.

    Interpretation: if this step changes the symptom, repeat the same controlled test once before moving on. If nothing changes, restore any temporary setting and continue. Keep a short note of the time, action, and result; that record prevents circular troubleshooting.

    Installation and environment branches

    Home Assistant OS or appliance-style installs

    App works, Home Assistant fails: focus on authorization, Home Assistant egress, logs, and the current integration version.

    Container, network, or account variation

    App and Home Assistant fail: focus on the vendor account, service status, vacuum connectivity, and firmware.

    Partial failure versus complete failure

    Only the map fails: treat map data as a separate path from basic vacuum entities; capture the map-specific error.

    Multi-device or multi-hop environments

    One vacuum fails in a multi-vacuum home: compare model, firmware, Wi-Fi, sharing, region, and ownership rather than resetting the working devices.

    What not to do

    • Do not delete the integration, device, database, app registration, or proxy configuration merely because it is the fastest visible button. Deletion can remove evidence and create new entity identities.
    • Do not paste passwords, tokens, encryption keys, exact home coordinates, public URLs with credentials, or unredacted logs into a forum or support ticket.
    • Do not disable firewalls, TLS verification, authentication, or other security controls as a permanent workaround. A useful test must be narrow, timed, and reversed.
    • Do not make several network, software, and device changes together. Change one variable, observe the result, and keep the working rollback path.
    • Do not assume a restart is a diagnosis. A restart can temporarily hide timing, memory, radio, storage, or connectivity faults without correcting them.

    Verification checklist

    After reauthentication or network repair, reload the integration once and wait through a normal update interval. Confirm the main vacuum entity, battery, status, dock, map-related entities, and a safe read-only attribute update. Run one harmless command such as locate only if appropriate. Restart Home Assistant once and verify the integration returns without another prompt. Continue observing through a vacuum sleep/wake cycle; a five-minute success is not enough for a problem that previously returned daily.

    • The original symptom is gone under the same conditions that previously reproduced it.
    • The relevant log has no new matching error after a normal update or restart cycle.
    • Related entities, history, automations, or remote access still work.
    • The repair survives one controlled restart of the affected component.
    • Temporary troubleshooting exceptions have been removed or documented.

    Rollback and recovery

    If removal becomes unavoidable, record entity IDs, automation references, device name, rooms, and customization first, then make a backup. Re-add with the same owner account and region. Repair broken automation targets deliberately rather than accepting silent duplicates. A factory reset of the vacuum is a last resort and usually unnecessary for a Home Assistant authentication failure.

    If the evidence points to failing hardware, a vendor outage, an upstream regression, or corrupted data that matters, stop improvising. Preserve the backup and diagnostic record, then escalate with the exact version, timestamp, error, minimal reproduction, and steps already tested. That produces a safer and faster answer than repeated resets.

    Prevention

    • Keep the Roborock owner account and region documented securely.
    • Avoid repeated verification-code requests.
    • Maintain stable 2.4 GHz coverage around the dock and cleaning area.
    • Log firewall blocks before creating narrow allow rules.
    • Back up Home Assistant before Core upgrades.
    • Track recurring prompts with timestamps to distinguish token expiry from random Wi-Fi loss.

    Schedule a brief review after the next Home Assistant update or device firmware change. Confirm that the repaired path still works, remove obsolete workarounds, and update your private documentation. Prevention is most effective when it records why a setting exists, not just its value.

    Diagnostic worksheet

    For Roborock devices that are unavailable or repeatedly require reauthentication in Home Assistant, write down five facts before asking for help: the exact error, the first failure time, the last working time, the smallest action that reproduces it, and the layer that still works. Add the Home Assistant Core version, installation type, relevant device or app firmware, network path, and whether the issue survives a restart. This worksheet separates a repeatable defect from a transient outage.

    If you observe: All Roborock entities become unavailable while the official app still controls the vacuum

    Confirm when this began and whether it affects one entity, one device, one integration, or the whole installation. Compare the result on the same network and, when relevant, through the alternate path. Then use the matching diagnostic step above. Do not jump to recovery until the observation is repeatable or the logs identify the failing layer.

    If you observe: Settings → Devices & Services shows Reconfigure or Reauthenticate for Roborock

    Confirm when this began and whether it affects one entity, one device, one integration, or the whole installation. Compare the result on the same network and, when relevant, through the alternate path. Then use the matching diagnostic step above. Do not jump to recovery until the observation is repeatable or the logs identify the failing layer.

    If you observe: Setup fails after entering the emailed code, sometimes with “unexpected error” or “failed to get home data

    Confirm when this began and whether it affects one entity, one device, one integration, or the whole installation. Compare the result on the same network and, when relevant, through the alternate path. Then use the matching diagnostic step above. Do not jump to recovery until the observation is repeatable or the logs identify the failing layer.

    If you observe: The map stops updating while basic commands still work, or the integration recovers after the vacuum reconnects

    Confirm when this began and whether it affects one entity, one device, one integration, or the whole installation. Compare the result on the same network and, when relevant, through the alternate path. Then use the matching diagnostic step above. Do not jump to recovery until the observation is repeatable or the logs identify the failing layer.

    If you observe: The problem returns every few hours or days despite successful reauthentication

    Confirm when this began and whether it affects one entity, one device, one integration, or the whole installation. Compare the result on the same network and, when relevant, through the alternate path. Then use the matching diagnostic step above. Do not jump to recovery until the observation is repeatable or the logs identify the failing layer.

    Frequently asked questions

    Should I delete and add everything again?

    Usually not. Re-adding can change entity IDs, erase evidence, and hide the original cause. Use it only after backup, documentation, and the narrower checks in this guide.

    Can I ignore the error if it starts working again?

    A single brief interruption may be harmless, but a recurring error deserves timestamps and logs. Repetition after the same event often reveals a network, storage, power, permission, or token lifecycle problem.

    Is updating Home Assistant always the fix?

    No. Updates can contain fixes, but they also change dependencies and behavior. Read release notes, back up first, and match the error to a known fix before treating an update as diagnosis.

    How much log information should I share?

    Share the smallest relevant window around the failure, with secrets and personal data removed. Include versions and the exact action that caused the event. Avoid uploading complete logs publicly.

    When should I escalate?

    Escalate when safety, important data, repeated corruption, an upstream regression, or an account-side failure is involved, or when the least-destructive checks produce a clear error you cannot resolve.

    Sources and review notes

    Photo: Onur Binay on Unsplash. Last reviewed: September 22, 2026. Official documentation is the authority for supported configuration. Community and issue reports are useful for identifying recurring symptoms but do not prove that every installation has the same cause.

    Continue with the Device Unavailable Diagnostic, the Smart-Home Diagnostic Decision Tree, or the Home Assistant Error Decoder when the symptom crosses more than one integration.

  • Samsung TV not authorized in Home Assistant: permissions, token, network, and Wake-on-LAN fixes

    Samsung TV not authorized in Home Assistant: permissions, token, network, and Wake-on-LAN fixes

    Direct answer: If a Samsung TV is unavailable in Home Assistant or will not turn on, first confirm that the television is supported, connected to the same subnet as Home Assistant, and reachable at its current IP address. For power-on failures, verify that Home Assistant knows the TV’s MAC address and that network standby or Wake on LAN is enabled on the television. Do not delete the integration or factory-reset the TV until you have separated an IP, permission, VLAN, and wake-up problem.

    This guide applies primarily to Samsung Smart TVs with Tizen from 2016 onward and models that expose the REST and WebSocket interfaces used by Home Assistant. Older H- and J-series televisions can use a different encrypted pairing flow, so their behavior may not match a newer Tizen model.

    Symptoms and scope

    • The Samsung TV entity shows Unavailable even though the television is powered on.
    • Home Assistant can turn the TV off but cannot turn it on.
    • The TV asks for permission every time Home Assistant connects.
    • The entity works briefly and becomes unavailable after the router assigns a new address.
    • Discovery fails when the TV and Home Assistant are on different VLANs.
    • Volume, source or remote commands fail while basic power state still updates.
    • An automation calls media_player.turn_on, but nothing happens.

    Before making changes

    Record the exact TV model, model year, firmware version, current IP address, wired or wireless connection, MAC address and Home Assistant version. In Home Assistant, open Settings → Devices & services → Samsung Smart TV and download diagnostics if the integration provides that option. Note the entity ID before removing or renaming anything because dashboards and automations may depend on it.

    Safety and privacy: Do not open the television or power supply. Disconnecting a wall-mounted TV can create a fall or electrical hazard. Do not publish a full diagnostic file without reviewing it for local IP addresses, MAC addresses, device names or tokens. Avoid exposing the TV’s control ports to the public internet.

    Fast diagnostic matrix

    Observation Likely layer Safest next step
    TV is unavailable while powered on IP, subnet, permission or WebSocket connection Compare the router’s current IP with the integration host
    TV turns off but not on Wake on LAN or network standby Verify the MAC address and wake settings
    TV asks for permission repeatedly Samsung Device Connection Manager Set access notification to First time only
    Failure began after moving the TV to an IoT VLAN Known subnet limitation Test TV and Home Assistant on the same subnet
    Remote commands fail on an older H/J model Legacy encrypted pairing Complete the TV’s pairing prompt and preserve the entry
    State works but a specific key does not Model-specific command support Test a documented basic command before changing the integration

    1. Confirm the television itself is online

    Start with checks that do not alter configuration. Turn the TV on with its physical remote. Confirm that a built-in streaming app can reach the network and that the router lists the TV as a connected client. If the TV is absent from the router, Home Assistant cannot repair the underlying network connection.

    For Wi-Fi, check that the TV joined the intended network rather than a guest SSID. Guest networks commonly isolate clients from one another. For Ethernet, confirm link lights on the switch or router and inspect the cable without moving a wall mount unsafely. Restarting the TV is reasonable only after you have recorded its current address and the affected appliance can safely lose power.

    If the router shows the TV online, note its IP and MAC address. Do not rely on an address written down months ago. DHCP leases change after router replacements, long power outages or network redesigns.

    2. Check model and protocol compatibility

    The official Samsung Smart TV integration documents support for Tizen televisions from 2016 onward and models with WebSocket and REST capabilities. A “smart TV” label alone is not enough because Samsung used different control protocols across generations.

    If the model is from the H or J series, Home Assistant may detect an encrypted protocol and start a manual pairing flow. Complete the permission prompt shown by the TV rather than repeatedly deleting and adding the integration. If the model predates the documented interfaces, partial discovery does not guarantee reliable control.

    Before blaming a Home Assistant update, compare the model and firmware with the current official integration documentation and known issues. Do not install an unrelated custom component simply because it supports a similarly named model; running two integrations against the same TV can create duplicate entities and confusing connection attempts.

    3. Repair an incorrect IP address safely

    Compare the host stored in the Samsung integration with the router’s current client entry. If the addresses differ, use the integration’s Reconfigure option when available or update the entry through the supported setup flow. Preserve the existing entity whenever possible so automations and dashboards continue to reference the same object.

    After a successful connection, create a DHCP reservation in the router for the TV’s MAC address. A reservation keeps address management centralized and avoids selecting an address already assigned to another device. Do not choose an arbitrary static IP inside the router’s dynamic pool.

    Verify this layer while the TV is on. The media-player state should update, and a low-risk volume or mute command should work. If the entity still fails while the IP is correct, continue to permissions and subnet checks instead of cycling through random addresses.

    4. Fix repeated Samsung permission prompts

    Newer Samsung TVs can be configured to ask for permission on every connection attempt. That can make Home Assistant appear unreliable because reconnects wait for someone to approve the television prompt.

    On the TV, open Device Connection Manager → Access Notification and change the setting to First time only. Then open the device list in the same manager and remove stale or duplicated Home Assistant attempts. Reconnect once and approve the fresh request.

    Menus differ slightly by model and firmware. Do not change unrelated privacy or advertising settings just to locate this option. If the TV provides only Allow and Deny entries, remove the old Home Assistant record and allow the next connection once.

    Verify by turning the television off and on normally, waiting for the integration to reconnect, and checking that no new permission prompt appears. A single successful command without a reconnect is not enough to prove this issue is resolved.

    5. Diagnose VLAN and subnet failures

    The official integration documents a significant limitation: Samsung televisions may refuse WebSocket connections across different subnets or VLANs. A firewall rule that allows the port does not necessarily overcome a restriction enforced by the television itself.

    Test this cleanly by placing Home Assistant and the TV on the same subnet temporarily. If the integration connects there, the TV, credentials and basic integration are working. The failure is in the network boundary or the television’s same-subnet restriction.

    Do not respond by opening the entire IoT VLAN to the trusted network. Some networks can use a carefully designed proxy or IP masquerading rule, but that is router-specific and should be implemented only if you understand the security effect. The safest general solution is often to keep the TV and Home Assistant interface that controls it on a compatible local segment while restricting unrelated IoT traffic.

    Document the original VLANs and firewall rules before testing. Restore them if the experiment does not improve the connection.

    6. Fix “turn off works, turn on does not”

    Turning a television off uses an active connection. Turning it on is different because the TV’s normal control interface is asleep. Home Assistant therefore needs a wake mechanism.

    If the integration learned the TV’s MAC address during discovery, it can attempt Wake on LAN when the Turn on action is called. Check that network standby, power-on with mobile, IP remote, or Wake on LAN is enabled in the TV’s network or power settings. Samsung changes the wording between firmware versions.

    Wireless wake support varies by model. A television may disconnect Wi-Fi completely during deep standby even though Ethernet wake works. Test with the existing connection first; do not purchase adapters or run new cabling before confirming the model’s documented capability.

    If Home Assistant did not learn the MAC address, add the official Wake on LAN integration and create a controlled automation using the Samsung TV’s samsungtv.turn_on trigger and wake_on_lan.send_magic_packet action. Use the MAC address from the router or TV network page rather than guessing it.

    wake_on_lan:
    
    automation:
      - alias: "Wake Samsung TV"
        triggers:
          - trigger: samsungtv.turn_on
            entity_id: media_player.samsung_smart_tv
        actions:
          - action: wake_on_lan.send_magic_packet
            data:
              mac: "AA:BB:CC:DD:EE:FF"
    

    Replace the sample values with your own entity and MAC address. Do not publish the real MAC in a public support post. If broadcasts do not cross VLANs, configure the broadcast address only after confirming the router’s behavior and the Home Assistant documentation.

    7. Interpret Wake on LAN results

    A magic packet action only proves that Home Assistant sent a packet; it does not prove the TV received it or powered on. Watch the router client list and the television’s status LED. If the TV appears on the network several seconds later, the wake path worked even if the media-player entity needs more time to reconnect.

    If Ethernet wake works but Wi-Fi wake fails, the difference points to standby behavior rather than the integration. If neither works, confirm the MAC, wake setting and broadcast path. If the TV wakes from Samsung’s mobile app while away from home but not from a local magic packet, the app may be using a vendor cloud path that is different from Wake on LAN.

    Do not compensate with a smart plug unless the television manufacturer explicitly permits hard power interruption. Repeatedly removing mains power can corrupt settings and is not equivalent to a normal standby wake.

    8. Test remote commands and sources logically

    Once availability and power are stable, test one basic command such as volume up, mute or Home. Supported key codes vary by model. A failure of one application or source shortcut does not mean the entire integration is offline.

    Test commands individually before creating a sequence. Long sequences can run too quickly or behave differently depending on which screen is active. Add delays only after confirming every individual command is supported. Avoid factory or service-menu key codes; they can change calibration or other sensitive settings.

    For source selection, inspect the source list exposed by the media-player entity. Some models expose only TV and HDMI, while others expose applications. Do not hard-code a source name that the entity does not currently report.

    9. Capture useful diagnostics

    Enable debug logging from the integration menu, reproduce the failure once, then disable logging and download the file. Record whether the TV was awake, its connection type, subnet relationship, and whether the permission prompt appeared.

    Before sharing diagnostics, remove local addresses, MAC addresses, names and tokens. A useful issue report includes the exact model, model year, firmware, Home Assistant version, connection type, error time, steps already tested and whether same-subnet testing changed the result.

    Verification checklist

    • The TV is visible in the router at the reserved IP.
    • The model is within the integration’s supported protocol range.
    • The TV and Home Assistant can establish a connection on the same subnet.
    • The Device Connection Manager trusts Home Assistant without prompting repeatedly.
    • A basic command works while the TV is on.
    • The TV wakes from a known-good magic packet or documented native wake method.
    • The media-player entity reconnects after wake and stays available through multiple cycles.
    • Debug logging is disabled after testing.

    Rollback and recovery

    If a VLAN experiment fails, restore the original network assignment and firewall rules. If a new Wake on LAN automation causes repeated wake attempts, disable the automation and keep the Samsung integration itself. If you removed stale permission records, approve the next legitimate Home Assistant request once.

    If the integration was deleted, restore from a recent Home Assistant backup only when rebuilding the entity relationships would be more disruptive than the restore. A simple IP or permission error normally does not justify rolling back the whole system.

    Prevention

    • Reserve the television’s IP address in the router.
    • Keep the model, firmware, IP and MAC recorded privately.
    • Test network segmentation changes with the TV before making them permanent.
    • Use First time only for connection notifications when available.
    • Keep power-on logic separate from normal media-control automations.
    • Review Home Assistant and Samsung firmware release notes before major upgrades.
    • Avoid duplicate custom integrations controlling the same TV.

    Related Troubliq guides

    Start with the Smart-Home Diagnostic Decision Tree when the failing layer is unclear. Use the Device Unavailable Diagnostic for a broader network-first workflow. For another IP-change example, see WLED unavailable after an IP change. If VLAN routing is suspected across several products, compare the network isolation checks in Shelly unavailable in Home Assistant.

    Evidence, applicability, and safe verification

    • Applies to: the Home Assistant Samsung Smart TV integration and Samsung TVs that expose the required local-network control interface. Menu names differ by model and firmware.
    • Exact symptom covered: “Home Assistant is not authorized to connect to this Samsung TV. Check your TV’s External Device Manager settings to authorize Home Assistant,” plus unavailable entities and failed power-on attempts.
    • Least-destructive check: keep the TV on, confirm Home Assistant and the TV can reach each other locally, then approve the on-screen connection request in the TV’s External Device Manager before deleting tokens or re-adding the integration.
    • Expected result: the TV accepts the authorization request, Home Assistant stores a usable token where the model supports it, and a basic command works while the TV is awake. Wake-on-LAN is a separate path and may still require the correct MAC address and network broadcast handling.
    • Verification: reload the integration once, confirm the entity remains available, and test one reversible command such as mute or volume. Do not use a source-launch failure alone as proof that authorization failed.
    • Rollback: if a change worsens control, restore the previous IP reservation, VLAN/firewall rule, or MAC setting. Removing the integration should be a last resort because it can discard a working token and entity references.
    • Privacy and safety: do not publish TV tokens, MAC addresses, internal IPs, network captures, or diagnostic downloads without redaction. Avoid broad firewall rules; allow only the minimum local traffic required.
    • Testing disclosure: this guide is based on current official Home Assistant documentation and conservative network diagnostics. Troubliq did not physically test every Samsung model, firmware, router, or VLAN design.
    • Last reviewed: September 30, 2026.

    Sources and review record

    Last reviewed: September 21, 2026. Testing disclosure: Troubliq synthesized current official documentation and documented integration behavior. We did not claim hands-on testing with every Samsung model, firmware version or network design.

  • TP-Link Kasa or Tapo unavailable in Home Assistant: authentication, IP, VLAN, and camera fixes

    TP-Link Kasa or Tapo unavailable in Home Assistant: authentication, IP, VLAN, and camera fixes

    Direct answer: When a TP-Link Kasa or Tapo device is unavailable in Home Assistant, do not factory-reset it first. Confirm that the device still works in the vendor app, verify its current IP address, check whether the model now requires TP-Link account authentication, and enable Third-Party Compatibility when the firmware provides that control. If the device is on another VLAN, add it manually by IP because automatic discovery normally will not cross subnets.

    This guide applies to the official TP-Link Smart Home integration in current Home Assistant releases and covers Kasa plugs, switches, bulbs and power strips as well as supported Tapo plugs, lights, hubs, sensors, cameras and doorbells. It focuses on connection and authentication failures, not cloud outages in the Kasa or Tapo mobile apps.

    Symptoms this guide covers

    • A Kasa or Tapo device is present but all or most entities show Unavailable.
    • Home Assistant discovers the device but setup fails with an authentication or communication error.
    • A device worked until a firmware update, router replacement, password change or IP-address change.
    • The vendor app works, but Home Assistant cannot connect locally.
    • A device on an IoT VLAN is not discovered.
    • A Tapo camera is controllable but live view is missing or unavailable.
    • An old total-consumption or update sensor remains unavailable even though the physical device works.

    Before changing anything

    Record the device model, hardware revision, firmware version, current IP address and the exact error shown under Settings → Devices & services → TP-Link Smart Home. Download diagnostics if Home Assistant offers them. Do not paste credentials, tokens, public IP addresses, Wi-Fi passwords or unredacted diagnostics into a forum post.

    Electrical safety: Do not open a mains-powered plug, switch, power strip or wall device. If a hardwired switch must be inspected, isolate the circuit and use a qualified electrician. A factory reset can erase schedules, camera settings and network configuration, so it belongs near the end of the process.

    Quick decision table

    Observation Most likely layer Safest next check
    Device also fails in the Tapo or Kasa app Power, Wi-Fi, router or device firmware Confirm power and check the router client list
    Vendor app works; Home Assistant reports authentication failure Credentials or Third-Party Compatibility Verify the case-sensitive account email and compatibility setting
    Device moved to another VLAN Discovery or firewall routing Add the current IP manually and test same-VLAN access
    Only one historical sensor is unavailable Entity removed or no longer reported Identify the entity type before changing the integration
    Tapo camera controls work but live view does not Camera account or live-view option Check the separate camera account in the Tapo app
    Failure began after the DHCP lease changed Stored host address Reconfigure the entry with the current IP

    1. Separate a device problem from a Home Assistant problem

    Start with observations that do not change configuration. Confirm that the device has power and appears online in the correct Kasa or Tapo account. Then open the router’s client list and locate the device by hostname, vendor or MAC address. Compare the listed IP with the host saved in Home Assistant.

    If the vendor app cannot reach the device while your phone is on the same local network, Home Assistant is unlikely to be the first problem. Check Wi-Fi coverage, access-point association and whether client isolation is enabled. Power-cycle a removable plug only if the connected appliance can safely lose power. Do not power-cycle a refrigerator, medical device, server, pump or security system without considering the consequence.

    If the app works and the device answers at its current IP, continue with the integration-specific checks below. The official integration communicates locally even though newer devices may require TP-Link cloud-account credentials to authorize that local connection. That distinction explains why internet access during initial setup may matter even when normal control is local.

    2. Confirm model and firmware support

    The official Home Assistant documentation maintains a supported-device list and links to the python-kasa project for current hardware and firmware coverage. Match the exact model and, when available, the hardware revision. A similar product name is not proof of support. Hub-attached products can also have different capabilities from directly connected Wi-Fi devices.

    If the model is absent, do not repeatedly delete and recreate the integration. First compare the device against the current python-kasa support table and known issues. An unsupported model may partially identify itself but still fail during feature negotiation. Preserve diagnostics for a maintainer report rather than guessing at credentials or ports.

    Firmware can change authentication requirements. Newer Kasa and Tapo devices commonly require the TP-Link cloud username and password for local authorization. Older devices that never required authentication may behave differently. Avoid downgrading firmware unless TP-Link or the integration maintainers provide model-specific instructions; an interrupted or incompatible firmware change can permanently disable a device.

    3. Fix authentication without exposing credentials

    Open the integration entry and choose Reconfigure when that option is available. Use the TP-Link cloud username associated with the device. Home Assistant’s documentation notes that this is normally the account’s case-sensitive email address. Do not use the separate camera account username in the general TP-Link account field.

    If setup fails after a password change, update the integration with the new account password instead of deleting the device. Deletion can break entity-based automations and dashboards if replacement entities receive different identifiers.

    Some firmware versions require an explicit compatibility switch in the vendor app. Depending on the product line and app version, look under Tapo Lab → Third-Party Compatibility or Settings → Third-Party Compatibility. Enable it only for devices you intend to expose to the official integration, then retry reconfiguration. This setting is preferable to an immediate factory reset because it preserves device placement, schedules and account association.

    Do not test credentials with random third-party websites or paste them into terminal commands copied from strangers. If advanced testing with the official python-kasa command-line tool is necessary, run it only on a trusted computer and avoid saving the command—with its password—in shell history.

    4. Correct IP-address and DHCP problems

    A router restart, lease expiration or replacement can assign a different address. If Home Assistant still targets the old address, reconfigure the integration with the current IP. After it works, create a DHCP reservation in the router so the same MAC address receives the same IP. A reservation is usually safer than manually assigning an address on the device because the router remains the source of truth and can prevent conflicts.

    Verify the repair by watching the integration for at least several polling cycles and operating one low-risk entity. The official integration normally polls device state every five seconds and updates immediately after a Home Assistant command. A single successful toggle is useful, but ten to fifteen minutes without another availability drop is better evidence.

    If the address changes again despite a reservation, check for duplicate MAC entries, mesh nodes using isolated guest networks, or a second DHCP server. Do not solve an address conflict by choosing an arbitrary static address that might already be in the DHCP pool.

    5. Handle VLANs and discovery correctly

    Automatic discovery generally does not cross subnets. A Kasa or Tapo device on an IoT VLAN may work perfectly yet never appear in the Discovered section. Add the integration manually using the device’s IP address.

    If manual setup also fails, temporarily place Home Assistant and the device on the same trusted test network. If the connection works there, the integration is probably healthy and the remaining issue is routing or firewall policy. Restore the intended network afterward and permit only the traffic required between Home Assistant and the device. Avoid broad “allow any” rules between an untrusted IoT VLAN and your main network.

    Multicast reflection is not a universal cure. Discovery and steady-state control are separate phases: discovery may rely on local broadcast behavior, while normal control uses the device’s unicast IP. Document which phase fails before changing mDNS, IGMP or multicast settings.

    6. Fix Tapo camera live view separately

    Tapo camera and doorbell live view has an additional prerequisite. In the Tapo app, create or verify the camera account under Device Settings → Advanced Settings → Camera Account. This camera-specific username and password are different from the main TP-Link cloud-account credentials.

    When adding or reconfiguring the integration, enable Live view and enter the camera-account credentials only in the camera fields. If you do not want live video in Home Assistant, leave Live view disabled; other supported controls can still be used.

    If live view alone fails, do not reset the whole camera. First disable and re-enable the camera-account option or reset only those camera-account credentials in the Tapo app, then reconfigure Home Assistant. Review privacy mode before troubleshooting a missing stream, and never expose RTSP or camera web ports directly to the public internet.

    7. Recognize removed or historical entities

    Not every unavailable entity means the device is offline. The official documentation identifies historical sensors that may remain in the entity registry after integration behavior changes.

    The total consumption sensor is reported by some older Kasa devices. Tapo and newer Kasa devices may not provide it. A newer device can therefore work normally while that one entity remains unavailable. Likewise, a legacy update-available binary sensor was removed because the cloud check was unstable. If an unavailable entity ends with an update-related identifier, confirm its history and documentation before deleting only that stale entity.

    Deleting a stale entity is different from deleting the device or integration. Take a screenshot or note its entity ID first, confirm that no automation or dashboard depends on it, and remove only the obsolete registry entry.

    8. Eliminate conflicts with custom integrations

    Disable custom integrations that also communicate with the same TP-Link devices. Two integrations can compete for sessions, create duplicate devices or make error messages misleading. Restart Home Assistant after disabling the custom component, then test the official integration by itself.

    Do not delete custom-component files while troubleshooting. Disable the component through its documented method, keep a record of its version and preserve a backup. If the official integration works alone, choose one integration and migrate deliberately rather than running both indefinitely.

    9. Use logs without creating a privacy problem

    Enable debug logging from the TP-Link integration’s menu, reproduce the failure once, then disable logging and download the file. The official documentation also describes logger entries for homeassistant.components.tplink and kasa. Debug logging can grow quickly, so do not leave it enabled.

    Before sharing a log, remove account email addresses, IP addresses if your threat model requires it, camera names, Wi-Fi identifiers, tokens and any credentials. A useful escalation report includes the exact model, hardware revision, firmware version, Home Assistant version, integration error, whether the vendor app works, whether both systems share a subnet, and the least-destructive checks already completed.

    Verification checklist

    • The device appears online in the vendor app and router client list.
    • Home Assistant uses the device’s current reserved IP.
    • The exact model and firmware are supported.
    • The case-sensitive TP-Link account email is correct.
    • Third-Party Compatibility is enabled when the firmware requires it.
    • Manual-IP setup is used across VLANs instead of relying on discovery.
    • Camera live view uses the separate camera-account credentials.
    • Only obsolete entities—not the whole working device—are removed.
    • Debug logging is turned off after the test.

    Rollback and recovery

    If a change makes the situation worse, restore the previous VLAN rule, move the device back to its original network, or re-enter the former integration host. Restore Home Assistant from a current backup only when configuration damage is confirmed; a network or authentication failure normally does not justify a full restore.

    If you must factory-reset the device, first export or document automations, schedules, camera privacy settings, entity IDs and room assignments. Reset one device at a time. Re-add it to the official app with the exact model selection, confirm local operation, then reconfigure Home Assistant. This prevents a broad reset from hiding the original cause.

    Prevent the problem from returning

    • Create DHCP reservations for locally controlled smart-home devices.
    • Record models, firmware versions, VLANs and integration ownership.
    • Review firmware release notes before enabling automatic updates on critical devices.
    • Keep a current Home Assistant backup and an offline copy of essential configuration.
    • Use one supported integration per device whenever possible.
    • Test IoT firewall changes with one noncritical device before applying them broadly.
    • Periodically review disabled and unavailable entities for documented removals.

    Related Troubliq guides

    For a protocol-neutral path, start with the Smart-Home Diagnostic Decision Tree or the Device Unavailable Diagnostic. If the symptoms began after a local address change, compare the process in WLED unavailable after an IP change. For another integration where discovery and local transport must be separated, see SwitchBot device not discovered.

    Sources and review record

    Last reviewed: September 20, 2026. Testing disclosure: This guide synthesizes current official documentation and documented integration behavior. Troubliq did not claim hands-on testing with every listed model or firmware version.

  • Duplicate devices after Home Assistant 2026.8: safe repair

    Duplicate devices after Home Assistant 2026.8: safe repair

    Direct answer: If devices appear duplicated after upgrading to Home Assistant 2026.8, do not immediately delete one, merge registries manually, or re-pair the hardware. The release changed how Home Assistant represents some physical products that are supplied by more than one integration. Review Settings, System, Repairs, follow the official repair when one is offered, and then check automations or scripts that target a device ID directly. Entity-based actions usually continue to address the same entities, but unusual configurations need verification.

    What changed in Home Assistant 2026.8

    Home Assistant’s August 2026 release introduced groundwork for more flexible device handling. The official release notes explain that a product previously represented as one device can be split when different integrations provide different parts of it. In rarer cases where the same device was configured through more than one integration, Home Assistant may raise a repair.

    The release notes state that automations and scripts generally keep working because actions are still sent to the appropriate devices. They specifically identify device-ID-based automations and unusual setups as areas that may deserve review. This is not the same as a random duplicate created by pairing a radio device twice, restoring an old registry, or adding both a local and cloud integration.

    Symptoms covered by this guide

    • One physical product appears as two device cards after the 2026.8 upgrade.
    • Entities that were grouped together now appear under separate devices.
    • A new repair mentions a device represented by multiple integrations.
    • An automation using a device trigger or device action behaves differently.
    • A dashboard still works but the device page looks reorganized.
    • You cannot tell whether the second device is intentional or stale.

    Before making changes

    1. Create and download a current Home Assistant backup.
    2. Record the Core version and installation type.
    3. Capture the repair text and both device pages.
    4. List the integrations shown on each device page.
    5. Record entity IDs, device IDs where visible, area assignments, and disabled entities.
    6. Export or copy important automations and scripts that reference the device.

    Do not edit the device registry or entity registry files manually on a running system. Do not delete database rows. Registry corruption can affect more than the visible duplicate and may leave automations pointing to identifiers that no longer exist.

    Step 1: Determine whether the split is expected

    Open each device card under Settings, Devices & services, Devices. Compare manufacturer, model, serial or hardware identifiers, entities, and the integrations listed. An expected split may place different functional groups under separate representations because distinct integrations provide them.

    For example, one integration may provide local device controls while another provides a service-level function. The visible names may be similar even though the representations have different ownership. Do not rename them solely to make the distinction disappear; first understand which integration supplies each entity.

    Step 2: Read the Repairs entry completely

    The Repairs integration is enabled by default and lists issues under Settings, System, Repairs. Each repair either offers a guided fix or provides information about the required action. Open the item and read every step before confirming it.

    If the repair is related to the 2026.8 device-handling change, follow the official flow. Avoid using a generic “ignore” choice until you know what remains unresolved. Take screenshots or notes so you can compare device and entity mappings after completion.

    Step 3: Identify other causes of apparent duplicates

    Not every duplicate after an upgrade is caused by the new device model. Check whether the same product was added through multiple paths:

    • A manufacturer cloud integration and a local protocol integration.
    • HomeKit Device and Matter for the same accessory.
    • ZHA and Zigbee2MQTT records from a migration.
    • Two configuration entries for the same network service.
    • A restored backup plus newly discovered hardware.
    • An old unavailable device with no entities and a new active device.

    Multiple integrations can be intentional. A cloud entry may expose functions that the local path does not, while the local path offers better responsiveness. Decide based on ownership, reliability, privacy, and entity requirements rather than the number of cards alone.

    Step 4: Compare entity registries before deleting anything

    Open each entity and record its entity ID, integration, device association, state, and where it is used. Home Assistant’s interface can show related automations, scripts, scenes, and dashboards. An unavailable entity can still be referenced by an automation, so absence of a current state does not prove it is safe to delete.

    Look for equivalent entities with different IDs, such as a cloud switch and local switch controlling the same relay. Test only a non-critical control and confirm which physical function changes. Do not experiment with locks, garage doors, alarms, mains-powered heating, irrigation, or other safety-sensitive systems without appropriate safeguards.

    Step 5: Audit device-based automations

    Automations can target entities or devices. Entity actions reference an entity ID, while device triggers, conditions, and actions can store a device identifier and integration-specific details. The 2026.8 release notes call out device-ID-based automations for review after a split.

    Open each related automation in the visual editor and inspect triggers, conditions, and actions. If YAML mode is used, save a copy before editing. Confirm which new device contains the required trigger or action. Do not replace every reference mechanically; the correct representation can differ by function.

    After a repair, trigger each non-critical automation under controlled conditions. Check traces to verify that the expected trigger fired, conditions evaluated correctly, and the intended entity received the action.

    Step 6: Check scripts, scenes, dashboards, and areas

    Scripts and scenes usually reference entities, but device actions are also possible. Dashboards can contain entity cards, device pages, conditional cards, and area-based views. Search for unavailable or renamed entities and update only confirmed stale references.

    Check area assignments on both device representations. A split can leave functions in different areas, which affects area-based voice commands, dashboards, and automations. Assign each representation according to the physical location and how Home Assistant uses the area.

    Step 7: Decide whether one integration should be removed

    Remove a configuration entry only after proving it is redundant and documenting what it owns. Use the integration’s official removal flow. Some integrations remove devices and entities immediately; others leave registry entries until cleanup conditions are met.

    Before removal, list unique capabilities, authentication requirements, cloud dependencies, update frequency, and automations using its entities. Prefer the path that meets your reliability and privacy needs, but do not assume “local” and “cloud” are interchangeable. The local path may not expose every function.

    Step 8: Handle a stale unavailable device

    If one device has no active entities and belongs to a removed configuration entry, Home Assistant may allow it to be deleted. Confirm that it is not a bridge, service device, or parent of hidden entities. Check disabled entities as well as visible ones.

    Delete through the user interface only when Home Assistant offers the action and all references have been reviewed. If deletion is unavailable, investigate the owning integration instead of manipulating registry storage manually.

    Step 9: Review custom integrations

    The 2026.8 release notes say most custom integrations require no immediate changes, but developers working directly with device information should review the developer guidance. If the duplicate involves a custom integration, check its repository for a release compatible with your exact Core version.

    Do not copy unreviewed patches into production. Custom integrations are outside the official project’s normal support boundary and can affect registry behavior. Back up, read release notes, and test updates one at a time.

    How to verify the repair

    1. Clear or complete the relevant Repairs item.
    2. Restart Home Assistant once under controlled conditions.
    3. Confirm the expected device representations return.
    4. Check that all required entities have current states.
    5. Run important non-critical automations and inspect traces.
    6. Verify scripts, scenes, dashboards, area controls, and voice exposure.
    7. Review logs for registry, config-entry, or platform errors.
    8. Wait through at least one normal integration update cycle.

    Common mistakes to avoid

    • Deleting the first device that shows unavailable.
    • Assuming similar names prove two records are duplicates.
    • Removing a cloud integration before checking unique entities.
    • Editing registry JSON files directly.
    • Re-pairing Zigbee, Z-Wave, Matter, or HomeKit hardware without evidence.
    • Ignoring device-based automations after the split.
    • Restoring an old backup without considering later changes.
    • Renaming entities before recording their original IDs.

    Rollback and recovery

    If a guided repair or integration removal breaks automations, stop additional changes. Restore saved automation YAML or update references to the verified new device and entities. If many registry relationships are damaged, a full backup restore may be safer than manual reconstruction, but it also reverses changes made after the backup. Review the backup date and preserve the current system before restoring.

    When radio devices are involved, avoid factory resets during registry cleanup. Radio pairing state can reside in both the controller and endpoint. A reset can turn a user-interface organization problem into a network re-pairing problem.

    When to escalate

    Collect the Core version, previous version, installation type, repair text, integration names, device identifiers with sensitive values redacted, entity mappings, relevant logs, and steps that reproduce the problem. State whether the setup uses official or custom integrations and whether the duplicate existed before 2026.8.

    Search the Home Assistant Core issue tracker and the relevant integration repository. If filing a new report, focus on one reproducible behavior. Do not upload a complete backup, secrets file, tokens, precise location, or unreviewed diagnostic archive.

    Prevention and maintenance

    • Read release notes before major monthly upgrades.
    • Keep verified backups and matching recovery material.
    • Document integrations that represent the same physical product.
    • Prefer stable entity naming and avoid unnecessary renames.
    • Review device-based automations after device-registry changes.
    • Remove obsolete configuration entries through supported interfaces.
    • Track custom-integration compatibility separately.

    Use automation traces to find hidden device references

    A device-based automation can look correct in the visual editor while its stored reference still points to the representation that changed. Open the automation’s recent traces and inspect the trigger, conditions, and action path. A trace can show whether the trigger never fired, a condition evaluated against an unavailable entity, or an action targeted a device that no longer offers the expected capability.

    When correcting a reference, change only the affected trigger or action and save a copy of the previous YAML. Then reproduce the event safely and compare the new trace. This is more reliable than replacing every similar device name across the system.

    How names can make an intentional split look like an error

    Home Assistant may derive names from the product, integration, room, and entity descriptions. After a split, two legitimate records can inherit nearly identical names. Give them clear display names only after you identify their roles—for example, distinguishing a local control representation from a cloud service representation. Renaming improves clarity but does not merge ownership or change which integration updates an entity.

    Avoid changing entity IDs during the first investigation. Entity-ID changes can ripple through YAML, templates, dashboards, notifications, and external consumers. Stabilize the device relationships first, then make naming changes deliberately with a reference audit.

    Check voice assistants and external consumers

    Google Home, Alexa, HomeKit bridges, Node-RED, MQTT consumers, and dashboards outside Home Assistant may refer to entity IDs or exposed-device selections. After completing the repair, review exposed entities and look for a duplicate display name in the external platform. Do not delete the external copy until Home Assistant’s source entity is understood.

    If an external platform retains a stale device, sync or rediscover through its supported procedure after Home Assistant is stable. Re-linking an entire account can affect rooms, routines, and names, so use the smallest supported refresh first.

    Special care for bridges and multi-channel products

    A bridge, power strip, multi-relay module, or climate system can legitimately contain many entities and child devices. Two cards do not necessarily represent two copies of the hardware. One may represent the bridge or service while others represent endpoints. Check the “via device” relationship and integration ownership before removing the parent.

    For Zigbee, Z-Wave, Matter, and HomeKit, registry cleanup is not the same as radio removal. Exclusion, unpairing, or factory reset changes network credentials and should be reserved for a proven communication or ownership problem. A device-page reorganization after 2026.8 does not by itself justify radio changes.

    2026.8 duplicate-device decision table

    What you see Likely meaning Safest next step
    Two device pages, each owned by a different integration The former cross-integration merged device was split as designed Keep both until you confirm which entities and automations belong to each integration
    A Repairs notification after upgrading Home Assistant detected a device-registry case that needs guided review Follow the repair text; do not delete registry records first
    Duplicate-looking cards but different entity sets One physical product is represented by separate integration responsibilities Rename the device pages for clarity and leave entity ownership intact
    An entity is unavailable or orphaned The issue may be an integration/config-entry failure rather than the 2026.8 split Check the entity’s integration, config-entry status, and logs before cleanup
    An automation reports an unknown device A device-based trigger or action may reference the pre-split registry entry Re-select the intended device/entity in a copy of the automation, test it, then replace the original

    Verify before deleting or merging anything

    Open each device page and record its integration, identifiers, entities, and automation links. The official 2026.8 change assigns a device to one config entry instead of merging information from several integrations. A physical product may therefore appear once for its primary integration and again for a router or tracker integration. That is not automatically corrupt data.

    Use a reversible test: rename each device page temporarily with its integration name, run one device-based automation, and operate one entity from each page. If both pages control or report distinct functions, keep them. If a repair explicitly instructs you to choose an entry, follow that guided flow and recheck automations afterward. Do not unpair Zigbee, exclude Z-Wave, reset Matter credentials, or factory-reset HomeKit accessories merely because the registry presentation changed.

    Expected result: entities remain attached to the correct integration-owned device, existing entity-based automations continue working, and any affected device-based automation is deliberately remapped. Rollback: restore the original automation from its backup or traceable copy and reverse temporary display-name changes. Registry deletion is not a rollback strategy because it can remove references without fixing the owning integration.

    Evidence and testing disclosure: This diagnostic order is based on the Home Assistant 2026.8 release notes and the official developer explanation of single-config-entry device ownership. Community reports are treated only as examples of impact, not proof of a universal defect. Troubliq did not reproduce every integration combination. Last reviewed October 1, 2026.

    Sources

    Last reviewed: September 8, 2026.

    Related Troubliq guides: Use the least-destructive diagnostic method, browse all troubleshooting guides, and read Matter device unavailable troubleshooting when the apparent duplicate involves a Matter accessory.

    Decision summary

    Follow the official repair when Home Assistant identifies a 2026.8 representation issue. Audit device-based references when functions moved between device records. Keep multiple integrations when each supplies needed capabilities. Remove an entry only after documenting its entities and dependencies. Delete a stale device only through the supported interface after confirming that it owns nothing required. This evidence-first process prevents a cosmetic duplicate from becoming lost automations, missing entities, or an unnecessary radio rebuild.

    Find your next troubleshooting path

    Use the related guide that matches the next confirmed layer of the failure. Avoid changing unrelated systems at the same time.

  • Alexa Devices integration becomes unavailable in Home Assistant: diagnose Service Unavailable errors

    Alexa Devices integration becomes unavailable in Home Assistant: diagnose Service Unavailable errors

    Direct answer: If the Alexa Devices integration becomes unavailable in Home Assistant after working normally, first identify whether the failure is an Amazon service response, an authentication problem, or a local Home Assistant issue. A log entry containing Service Unavailable after earlier successful updates does not by itself mean that your password or multi-factor authentication is wrong. Preserve the logs, verify Amazon services and local connectivity, reload the integration once, and reauthenticate only when Home Assistant explicitly reports an authentication failure.

    Symptoms covered by this guide

    • Alexa speakers and related entities become unavailable together.
    • The integration works after setup or reload but later stops updating.
    • Logs show Service Unavailable, CannotRetrieveData, timeouts, or failed coordinator updates.
    • Reloading the integration temporarily restores entities.
    • Home Assistant requests reauthentication or rejects a one-time password.
    • The Alexa app works while Home Assistant cannot update Alexa entities.

    This guide concerns the official Alexa Devices integration documented by Home Assistant. It does not cover every custom Alexa component, the separate Alexa Smart Home skill, or general voice-assistant exposure. Confirm the integration name before applying any step.

    Why Alexa Devices can become unavailable

    The integration depends on several layers: Home Assistant, its network and DNS path, Amazon account authentication, multi-factor authentication, and Amazon endpoints that return device and communication data. A failure in any layer can make many entities unavailable at once. The correct recovery depends on the error class.

    A public Home Assistant Core issue filed for Core 2026.6.4 documents a recurring case in which initial authentication and updates succeeded, followed later by a Service Unavailable response. In that report, reloading restored operation without reauthentication. That is evidence of one observed failure pattern, not proof that every unavailable Alexa integration has the same cause or that the behavior affects every version.

    Before changing anything

    1. Record the Home Assistant Core version and installation type.
    2. Note when Alexa entities last updated successfully.
    3. Open Settings, System, Logs and save the exact redacted error.
    4. Confirm whether every Alexa entity failed or only one device.
    5. Check whether the Alexa mobile app can currently see and control the same devices.
    6. Create a current Home Assistant backup before deleting or reconfiguring the integration.

    Do not post Amazon passwords, authenticator secrets, one-time codes, cookies, tokens, full diagnostic archives, email addresses, or household information. Redact identifiers from screenshots and logs.

    Step 1: Distinguish service failure from authentication failure

    Read the first meaningful exception near the failed update. A server-side Service Unavailable or HTTP 503 response means the requested service did not complete the request at that time. It is different from an unauthorized or forbidden response. Authentication failures commonly mention invalid credentials, reauthentication, an expired session, unauthorized access, or a failed one-time password.

    If recent log entries show successful updates followed by a 503-style response, preserve that sequence. Do not repeatedly change the password. If the integration explicitly creates a repair or reauthentication flow, follow that flow using the official interface.

    Step 2: Confirm the scope outside Home Assistant

    Open the Alexa app and check device state. If the app also fails, the problem is likely upstream of Home Assistant: an Amazon service incident, account problem, household configuration, or device connectivity issue. If the app works, continue testing the Home Assistant path without assuming Amazon is fully healthy; different API functions can fail independently.

    Check Home Assistant’s System status and any relevant integration alert. Review the official Alexa Devices integration documentation for current prerequisites. Avoid relying on old forum instructions because authentication requirements and supported features can change.

    Step 3: Verify Home Assistant network, time, and DNS

    Cloud authentication can fail when the Home Assistant host has no reliable internet path, resolves DNS incorrectly, has an inaccurate clock, or is being filtered by a firewall. Confirm that other cloud integrations update normally. Review host, supervisor, and core logs for broader network failures.

    Accurate time matters for TLS certificates and time-based one-time passwords. Home Assistant OS normally manages time automatically, but a host that cannot reach its time source may drift. Check the host time and timezone rather than compensating by repeatedly generating codes.

    If you use a custom DNS server, ad blocker, outbound proxy, VLAN policy, or firewall, temporarily test a known-safe rule change only if you understand the impact. Do not disable perimeter security broadly. Record the result and restore the previous rule after the test.

    Step 4: Reload the integration once

    Go to Settings, Devices & services, locate Alexa Devices, open its menu, and choose Reload. Watch the logs while it reloads. A successful reload that restores all entities without an authentication prompt indicates that the saved credentials were still accepted at that moment.

    Reloading is a diagnostic action, not a permanent fix for a repeating upstream failure. Do not create an hourly reload automation as a first response. Repeated reloads can hide the timing and error needed for a useful bug report, increase traffic to an external service, and make the problem harder to diagnose.

    Step 5: Reauthenticate only when requested

    The official integration documentation requires an Amazon account and multi-factor authentication through an authenticator application, with the authenticator method configured appropriately in the Amazon account. Follow the current Home Assistant reauthentication flow and the official Amazon security interface.

    Enter the account email, password, and current one-time password only in the authorized setup form. Confirm that the authenticator device clock is accurate. If several attempts fail, stop briefly rather than triggering additional account protection. Verify that you selected the correct Amazon account and regional marketplace.

    If reauthentication succeeds but the integration later reports Service Unavailable, treat that as a separate runtime problem. Repeating the same login process is unlikely to fix a remote availability failure permanently.

    Step 6: Check account and household details

    Amazon Household membership, multiple profiles, regional accounts, and changes to security settings can affect available data. The official Home Assistant documentation notes a limitation involving reminders and accounts linked to an Alexa Household. Do not remove household members merely to test an unrelated unavailable-device problem.

    Review recent changes: password reset, multi-factor method change, marketplace move, household change, revoked sessions, or new security alerts. Resolve suspicious account activity directly through Amazon before reconnecting third-party software.

    Step 7: Rule out custom-component conflicts

    If both the official integration and a custom Alexa component are installed, confirm which one owns the failing entities and log messages. Custom integrations are maintained separately and can use different authentication or update methods. Review Settings, Devices & services and the custom integration store before deleting anything.

    Start Home Assistant in a controlled configuration only when you understand the consequences. Removing a custom integration can change entity IDs and break automations. Back up first and document current entity mappings.

    Step 8: Compare versions and known issues

    Record the exact Core version, not merely “latest.” Check the official release notes and the Home Assistant Core issue tracker for the same integration, error, and version. Read issue status and maintainer responses. A single open report does not establish a universal regression, and a closed report may be fixed only in a newer release.

    Do not downgrade Home Assistant casually. Restoring an older backup can also roll back database schema, integrations, and configuration. If maintainers recommend a specific patch release, review its release notes and create a verified backup before updating.

    How to interpret common results

    • Alexa app and Home Assistant both fail: investigate Amazon service, account, or device connectivity first.
    • App works; reload restores Home Assistant: preserve logs and investigate a coordinator, session, or remote endpoint failure.
    • Reauthentication requested: complete the official flow and verify the authenticator method.
    • 401 or unauthorized: focus on credentials, session, account region, and security changes.
    • 503 or Service Unavailable: avoid unnecessary password changes; check timing, service health, and known issues.
    • Only one entity fails: inspect that device, its account state, and whether the integration still exposes it.

    Verify the recovery

    1. Confirm the integration card shows no setup failure.
    2. Confirm several Alexa entities have fresh states.
    3. Test one non-critical entity or information update.
    4. Check logs for repeated coordinator errors.
    5. Wait longer than the previous failure interval.
    6. Confirm a normal Home Assistant restart does not immediately reproduce the problem.

    A successful reload is not sufficient when the problem previously returned after hours. Keep the observation window long enough to distinguish recovery from temporary relief.

    Rollback and safe recovery

    If a configuration change makes the problem worse, restore the previous DNS, firewall, or account setting and reload once. If you removed the integration, restore from a known backup only after considering changes made since that backup. Re-adding an integration may create different entity IDs, so review automations, dashboards, scripts, and exposed voice-assistant entities.

    When to escalate

    Prepare a concise report with the Core version, installation type, integration name, approximate failure time, first relevant stack trace, whether the Alexa app worked, whether Reload restored operation, and how long recovery lasted. Include diagnostics only after reviewing them for secrets. Search for an existing matching Core issue before creating a new one.

    If the error suggests account compromise, stop technical troubleshooting and secure the Amazon account. Change credentials through the official account page, review devices and sessions, and confirm multi-factor methods.

    Prevention

    • Keep Home Assistant on a supported release after reviewing breaking changes.
    • Maintain a verified backup before updates or integration removal.
    • Use a stable DNS and internet path for cloud integrations.
    • Keep the authenticator method available and its device clock accurate.
    • Document entity IDs before reconfiguration.
    • Avoid automated reload loops that conceal recurring faults.
    • Review integration alerts and release notes when behavior changes.

    Build a timeline instead of treating every log line as the cause

    Coordinator-based integrations can emit secondary errors after the first failure. Start with the earliest error in the same update cycle, then follow later messages in order. A timeout, DNS failure, or remote 503 can cause entities to become unavailable and produce additional warnings that are consequences rather than causes. Record the time of the last successful update, the first failed request, the moment entities changed state, and the result of one reload.

    Compare that timeline with other events: a Home Assistant update, router restart, DNS change, Amazon password change, authenticator change, or an internet interruption. Correlation is not proof, but a precise timeline helps eliminate unrelated changes. If no configuration changed and the error begins with a remote service response, avoid rebuilding the integration before checking whether the service recovers.

    Why aggressive retry automations are risky

    An automation that reloads a failing cloud integration every few minutes may appear convenient, but it can create repeated authentication or API traffic, conceal the original error, and interfere with normal backoff behavior. It can also leave dependent automations alternating between available and unavailable states. Use a single manual reload as a diagnostic step. If maintainers later document a temporary workaround, follow its exact limits and remove it when a fixed release is installed.

    Check dependent automations after recovery

    When Alexa entities return, review automations that ran during the outage. An unavailable sensor may have prevented a condition from evaluating as expected, and state-based triggers normally do not replay missed transitions automatically. Do not assume that restoring the integration will reproduce reminders, timers, or notifications that were missed.

    Use automation traces to confirm what happened. Test a non-critical path, verify entity state freshness, and inspect the trace for skipped conditions or unavailable inputs. Avoid testing announcements late at night or controls connected to safety-sensitive equipment.

    Regional and account consistency checks

    Confirm that the Amazon account, marketplace region, Alexa app session, and integration configuration refer to the same household. A region mismatch can resemble an empty or incomplete device list even when login succeeds. If the account has recently moved regions, document the previous and current marketplace before reconfiguration. Do not create duplicate Amazon accounts as a troubleshooting shortcut.

    Sources

    Last reviewed: September 8, 2026.

    Related Troubliq guides: Start with the safe diagnostic method, browse troubleshooting guides, and review Home Assistant automation trigger diagnosis when the integration is available but an automation still does not run.

    Final decision checklist

    Reload once when credentials appear valid and the error is a temporary service response. Reauthenticate when Home Assistant explicitly requests it or logs show authorization failure. Investigate local network and time when several cloud services fail. Wait and document when a remote endpoint returns a temporary 503. Escalate with redacted evidence when the failure repeats on a current supported release. This sequence addresses the most likely layer while protecting the account and preserving useful evidence.

    Find your next troubleshooting path

    Use the related guide that matches the next confirmed layer of the failure. Avoid changing unrelated systems at the same time.

  • HomeKit device says already paired in Home Assistant: safe recovery without losing setup

    HomeKit device says already paired in Home Assistant: safe recovery without losing setup

    Direct answer: A HomeKit device usually reports “already paired” because it still belongs to Apple Home, another HomeKit controller, or a previous Home Assistant pairing record. HomeKit accessories generally accept only one controller pairing at a time. First identify the current owner, remove the accessory from that controller, wait for it to become discoverable, and pair it with Home Assistant’s HomeKit Device integration. Factory reset is a last resort because it can erase Wi-Fi or Thread credentials, scenes, vendor settings, and automations.

    Symptoms and scope

    • Home Assistant discovers the accessory but pairing fails with an already-paired or unavailable message.
    • The HomeKit code is accepted, then setup stops.
    • The device still appears in Apple Home or another Home Assistant installation.
    • A restored Home Assistant instance sees the accessory but cannot control it.
    • The accessory was removed from Apple Home but does not appear in Home Assistant.
    • A Thread accessory keeps returning to an old Thread network.

    This guide concerns importing a physical HomeKit accessory into Home Assistant with the HomeKit Device integration, formerly called HomeKit Controller. It is different from HomeKit Bridge, which exports Home Assistant entities to Apple Home. Confusing the two integrations can send troubleshooting in the wrong direction.

    How HomeKit ownership works

    A HomeKit accessory establishes an encrypted pairing relationship with one controller. The controller might be an Apple Home, Home Assistant, or another compatible ecosystem. Adding a device to Apple Home and then trying to import it directly into Home Assistant without removing it from Apple Home normally fails because the accessory is still owned.

    The official Home Assistant documentation describes a useful Wi-Fi workflow: use Apple Home or the manufacturer’s app to place the device on the local network, then remove it from Apple Home. Removing it opens the HomeKit pairing again while the accessory may remain connected to Wi-Fi. Home Assistant can then discover and pair it locally.

    Thread devices require extra care. Removing a device from Apple Home without resetting it can leave its Thread credentials intact, allowing Home Assistant to discover it over the existing Apple Thread network. Resetting it may erase those credentials and require Bluetooth commissioning or provisioning onto Home Assistant’s preferred Thread network.

    Before you begin

    1. Find the eight-digit HomeKit pairing code on the device, packaging, manual, or display.
    2. Record the device’s current name, room, vendor app account, and automations.
    3. Confirm whether it connects through Wi-Fi, Ethernet, Bluetooth, or Thread.
    4. Back up Home Assistant before removing an existing integration or changing Thread networks.
    5. If it controls a lock, garage door, alarm, valve, heater, or other safety-sensitive equipment, keep the manufacturer’s supported control method available throughout the change.

    Home Assistant’s documentation states that a lost HomeKit pairing code cannot be recovered by Home Assistant. Contact the manufacturer if the code is missing. Do not repeatedly guess codes; some accessories impose timeouts.

    Step 1: Make sure you are using the right integration

    Open Settings → Devices & services. A discovered accessory intended for import should appear under HomeKit Device. HomeKit Bridge is not the pairing destination for a physical accessory; it exposes existing Home Assistant entities to Apple Home.

    If the accessory already exists as a vendor integration—such as a local manufacturer integration—decide which method you actually want. Do not pair through multiple paths merely to fix discovery. Duplicate integrations can create duplicate entities and conflicting automations.

    Step 2: Identify the controller that currently owns the accessory

    Check Apple Home, any previous Home Assistant server, family members’ homes, and vendor gateways. A device visible in Apple Home is paired even if it is offline. If you migrated Home Assistant, the old instance or an incomplete restore may still hold the pairing relationship.

    Do not delete the Home Assistant device entry first unless you are certain the accessory can be unpaired or reset. Deleting the controller record while the accessory retains its pairing can leave the two sides out of sync.

    Step 3: Remove it cleanly from Apple Home

    For a Wi-Fi or Ethernet accessory currently in Apple Home:

    1. Confirm it is online in Apple Home.
    2. Record any Apple Home scenes or automations using it.
    3. Use Apple Home’s remove-accessory action.
    4. Keep the accessory powered and connected to the same LAN as Home Assistant.
    5. Wait several minutes for HomeKit discovery to update.
    6. Check Home Assistant’s discovered integrations again.

    The important distinction is remove versus factory reset. Removal ends Apple Home’s controller pairing. A reset also clears the accessory’s local configuration and may be unnecessary for an IP device.

    Step 4: Check local discovery

    HomeKit IP accessories are normally discovered through local multicast DNS. Being able to ping the device does not prove mDNS can cross a VLAN, guest network, wireless isolation boundary, VPN, or container network. Place Home Assistant and the accessory on the same local network temporarily if possible.

    Check these conditions:

    • Client isolation or guest-network isolation is disabled for the test.
    • UDP multicast traffic is not blocked between the relevant interfaces.
    • The Home Assistant host has normal local-network access.
    • A container or VM network exposes multicast correctly.
    • No stale DNS override sends the accessory or Home Assistant through a public route.

    Change one network condition at a time. Avoid permanently opening broad inter-VLAN access just to make discovery work; a properly scoped mDNS reflector and the required device traffic are safer.

    Step 5: Pair an IP accessory

    1. Open the discovered HomeKit Device card in Settings → Devices & services.
    2. Select Configure.
    3. Enter the HomeKit code exactly as printed.
    4. Wait for the accessory to exchange keys and create entities.
    5. Assign it to an area and finish setup.

    If the code fails immediately, confirm you are using the HomeKit code rather than a Matter code, serial number, Wi-Fi password, or vendor setup PIN. Preserve the dashes or remove them only as the interface requests.

    Step 6: Handle Bluetooth accessories

    A Bluetooth HomeKit accessory must be within reliable radio range of Home Assistant or a supported ESPHome Bluetooth proxy. Battery devices may need to be awakened during pairing. Bluetooth pairing can take longer than IP pairing, so do not restart the accessory repeatedly while the exchange is active.

    Verify the Bluetooth adapter or proxy works with another known device. If the accessory was previously paired or joined to Thread, the official documentation advises resetting it before Bluetooth-based setup so old controller or Thread information does not interfere. Follow the manufacturer’s exact reset sequence and confirm the device re-enters pairing mode.

    Step 7: Handle Thread accessories without destroying the working mesh

    If a HomeKit-over-Thread accessory currently works in Apple Home and you want it to stay on Apple’s Thread network, remove it from Apple Home but do not reset it. The device can retain its Thread details and may then be discovered by Home Assistant over Thread. Pair it using the printed HomeKit code.

    If instead you want to move it onto Home Assistant’s preferred Thread network, first verify a working border router and known credentials. Pair through Bluetooth if required, then use the device configuration to provision the preferred Thread credentials. Do not delete Thread datasets or reset border routers to solve a single accessory problem.

    Step 8: Recover after a Home Assistant migration or partial restore

    A complete Home Assistant backup normally carries integration configuration, but a partial restore or manually rebuilt instance may not contain the old HomeKit pairing keys. The accessory can remain paired to keys the new instance does not have.

    1. Confirm whether a complete backup from the working instance exists.
    2. Prefer restoring the relevant known-good backup over resetting every accessory.
    3. If restoration is not possible, remove the accessory from its current controller through the supported UI.
    4. Reset only the individual accessory that cannot be cleanly unpaired.
    5. Pair one device and verify stability before repeating the process.

    If pairing succeeds but no entities appear

    Home Assistant supports many common HomeKit domains, including lights, switches, locks, climate devices, covers, fans, sensors, and alarms. The official documentation notes that an unsupported device type may appear in the Device Registry without creating usable entities. That is different from a pairing failure.

    Check the device page, disabled entities, diagnostic entities, and integration documentation. Do not repeatedly remove and re-pair a successfully paired accessory because its service type is unsupported.

    How to verify the fix

    1. Confirm the accessory is listed under HomeKit Device.
    2. Operate one non-destructive control in Home Assistant.
    3. Physically verify the device responds.
    4. Change the device state outside Home Assistant and confirm a push update returns.
    5. Restart Home Assistant once and confirm the device reconnects.
    6. For Thread, verify the reported Thread status after the mesh settles.

    Rollback and recovery

    If Home Assistant pairing fails after clean removal, you may re-add the accessory to Apple Home using its original pairing code, provided it remains in pairing mode. If the accessory was factory-reset, restore vendor settings and automations deliberately. For a security device, follow the manufacturer’s recovery process and test all physical safety functions.

    When to escalate

    Collect the Home Assistant version, device manufacturer and model, firmware, connection type, integration diagnostics, and relevant logs with secrets removed. Contact the manufacturer if the pairing code is missing or the reset process does not reopen pairing. Report reproducible integration failures to Home Assistant only after confirming the device is unpaired and discoverable.

    Prevention

    • Store HomeKit codes securely before installation.
    • Document which controller owns each accessory.
    • Back up Home Assistant before migrations.
    • Choose a Thread network intentionally and keep its credentials recoverable.
    • Avoid unnecessary factory resets.
    • Do not confuse HomeKit Device with HomeKit Bridge.

    Source

    Last reviewed: September 8, 2026.

    Related Troubliq guides: Thread credentials are synced but commissioning fails, Matter device pairs but shows unavailable, and the safe diagnostic method.

    Decision guide: remove, reset, or restore?

    Choose the least disruptive path that matches the evidence. If the accessory is visible and controllable in Apple Home, remove it from Apple Home first; do not reset it. If it is an IP accessory that was added to Wi-Fi through Apple Home, keep it powered after removal so it can remain on the network and advertise for a new controller. If it is a Thread accessory that should remain on an Apple Thread network, removal without reset preserves the best chance of retaining those network credentials.

    Use a factory reset only when the accessory cannot be removed from the controller that owns it, its previous controller no longer exists and no usable backup remains, or the manufacturer explicitly requires a reset to reopen pairing. Use restoration instead when the problem began after migrating Home Assistant and a complete backup from the working controller is available. Restoration can recover the pairing keys and prevent a house-wide reset campaign.

    After each action, wait for discovery to settle and test before escalating. Removing, resetting, restoring, and changing VLAN rules at the same time destroys the evidence needed to identify the real cause.

    How to preserve the original controller relationship before a reset

    Before resetting an accessory, identify every place where it may already be paired. Check Apple Home on each household member’s device, any older Home Assistant installation, vendor apps, and previous hubs that may still be powered. A HomeKit pairing record belongs to the controller’s Home data, not merely to the phone used during setup. Removing an app, changing phones, or deleting an integration card does not necessarily release the accessory.

    If the accessory still responds through Apple Home, record its room, name, scenes, automations, and any bridge or Thread border router involved. Remove it from the owning controller while it is powered and reachable, then wait for that removal to complete before attempting another pairing. This clean removal is preferable to a factory reset because it gives the controller an opportunity to discard its relationship and can preserve network settings that the accessory is designed to retain.

    For a bridged accessory, determine whether the HomeKit code belongs to the bridge rather than the individual endpoint. Resetting a child bulb, sensor, or switch may not clear the bridge-level pairing and can create extra recovery work. Consult the manufacturer’s instructions for the exact model because button sequences, LED meanings, and reset depths differ.

    Network checks when the pairing code is accepted but setup still fails

    An “already paired” message can be followed by a second problem: the old pairing is cleared, but discovery or communication fails. Confirm that the Home Assistant host and accessory can exchange local traffic. Multicast DNS must cross the relevant Wi-Fi or VLAN boundary, client isolation must not block peers, and firewall rules must permit the local path. For Thread accessories, confirm that a compatible border router is operational and that the phone used for commissioning has Bluetooth and local-network permissions.

    Do not merge these stages into one diagnosis. First prove that ownership was released; then investigate discovery, networking, or Thread credentials. This separation prevents repeated resets from hiding the actual fault.

    Evidence to collect for a useful support request

    If the accessory remains unavailable, record the exact model, firmware, connection type, Home Assistant version, installation type, integration name, and the complete redacted error. State whether the device is visible in Apple Home, the vendor app, Home Assistant discovery, or a network scan. Include the order of removal and pairing attempts, but never share HomeKit setup codes, QR codes, Wi-Fi credentials, diagnostic archives containing secrets, or account tokens.

    Find your next troubleshooting path

    Use the related guide that matches the next confirmed layer of the failure. Avoid changing unrelated systems at the same time.

  • MQTT entities unavailable after Home Assistant restart

    MQTT entities unavailable after Home Assistant restart

    Direct answer: When MQTT entities become unavailable after Home Assistant restarts, the most common problem is not the entity itself. Home Assistant has reconnected to the broker, but it has not yet received the discovery or availability messages required to rebuild the entity and mark the device online. The safest fix is to verify the broker connection, confirm the device republishes discovery after Home Assistant’s birth message, and check whether the availability message is retained. Do not delete the MQTT integration or recreate every entity until you know which message is missing.

    What this problem looks like

    • MQTT entities worked normally before a Home Assistant restart but return as unavailable.
    • The device is powered and still publishes data, yet its entities do not recover.
    • Reloading MQTT temporarily restores some or all entities.
    • Entities appear only after the physical device restarts.
    • Manually republishing a discovery payload makes the entity return.
    • The broker log shows Home Assistant reconnecting, but the expected discovery or online message is absent.

    This guide applies to MQTT discovery and manually configured MQTT entities. It is especially relevant to devices or bridges that generate Home Assistant discovery payloads, including custom firmware, gateways, scripts, and home-built sensors.

    Why MQTT entities can stay unavailable

    MQTT is message based. Home Assistant cannot infer a device’s current state merely because the broker is reachable. Depending on the entity configuration, it may need several different messages:

    • A discovery configuration message describing the entity.
    • A state message containing the current value.
    • An availability message such as online.
    • A new message before an expire_after timer runs out.

    Home Assistant’s MQTT documentation explains that, during startup, existing discovered devices and entities can remain unavailable until their discovery messages are received and processed. It recommends that devices subscribe to Home Assistant’s birth message and use it as a trigger to resend discovery. This matters when the original discovery configuration was not retained or when the publishing device started before Home Assistant.

    Availability is separate from state. A sensor may continue publishing a number while its availability topic still says offline. Conversely, an entity can be marked online but have an old or unknown state. Diagnose these message paths separately.

    Before changing anything

    1. Record one affected entity ID and its device name.
    2. Open the MQTT integration and download diagnostics if available.
    3. Copy the entity’s discovery topic, state topic, and availability topic.
    4. Note whether the failure happens after every restart or only intermittently.
    5. Back up configuration files before editing YAML, templates, automations, or broker settings.

    Avoid clearing retained topics broadly. Retained MQTT messages may be controlling discovery and availability for many devices. Deleting them without an exact topic list can remove working entities or revive stale configurations in confusing ways.

    Step 1: Confirm Home Assistant is connected to the correct broker

    Open Settings → Devices & services → MQTT. Confirm the integration is loaded and does not show an authentication or connection error. If you recently moved the broker, changed credentials, or restored a backup, verify the host, port, TLS setting, username, and broker instance.

    Use the MQTT listening tool in Home Assistant to subscribe temporarily to the affected device’s topic tree, such as device-name/#. Use the narrowest safe filter you know; avoid subscribing to # on a busy system for long periods. Restart or wake the affected device and observe whether messages arrive.

    If no messages arrive, the problem is upstream of the entity: device connectivity, broker permissions, an incorrect topic, or the publisher itself. If messages do arrive, continue and distinguish discovery, state, and availability.

    Step 2: Verify the discovery configuration is replayed

    MQTT discovery topics normally begin with the configured discovery prefix, commonly homeassistant/. Listen for the exact configuration topic used by the affected entity. A valid discovery message should contain the entity configuration and should be published again when needed.

    If the configuration is retained, a newly connected Home Assistant client should receive it from the broker. If it is not retained, the device or bridge must republish it after Home Assistant comes online. Many reliable publishers do both: retain the discovery configuration and also respond to the Home Assistant birth message.

    Check the publisher documentation before changing retain behavior. Retaining a discovery configuration is normal; retaining every kind of state or command message is not automatically correct.

    Step 3: Test the Home Assistant birth-message path

    Home Assistant publishes a birth message when MQTT becomes available. A discovery publisher can subscribe to that status topic and resend its configurations when it sees the online payload. If entities appear only after restarting the device, this replay path is probably missing or broken.

    1. Identify the birth topic and payload configured for Home Assistant.
    2. Confirm the publishing device or bridge subscribes to that exact topic.
    3. Check capitalization and spacing in the expected payload.
    4. Restart only the MQTT integration or Home Assistant once while listening.
    5. Verify that the publisher responds by sending its discovery configurations again.

    Do not create an automation that repeatedly floods discovery messages. One response to the relevant birth event is enough.

    Step 4: Inspect the availability topic and retained flag

    For an entity with an availability topic, Home Assistant uses the configured available and unavailable payloads. The defaults are often online and offline, but publishers can use other values. The payload must match exactly.

    The official MQTT binary-sensor documentation notes that when the availability message is not retained, a sensor may display unavailable after Home Assistant starts because no current availability message has arrived. Retaining the latest availability status allows a subscriber to receive it immediately. A device should normally publish a retained offline message through its Last Will and Testament and replace it with a retained online message after a successful connection.

    Check for these failure patterns:

    • The online message uses a different topic than the entity configuration.
    • The device publishes Online while Home Assistant expects online.
    • A retained offline message remains after the device reconnects.
    • Multiple availability topics require all topics to be online when any was intended.
    • The publisher reconnects without sending its current online state.

    Step 5: Separate state retention from availability retention

    Do not assume the state message should be retained because availability should be retained. The correct choice depends on the entity. A retained temperature reading can provide an immediate value after restart, but it may also present a stale reading as current. Home Assistant’s MQTT sensor documentation cautions against retaining state when expire_after is used because replaying an old retained value can make an expired sensor appear available again.

    For event-like data—button presses, motion events, one-shot commands—retaining the state is usually wrong. For a slowly changing measurement, retaining may be useful if the age and availability logic are handled correctly. Follow the device integration’s documentation.

    Step 6: Check expire_after and message frequency

    If the entity works briefly and then becomes unavailable, inspect expire_after. The publisher must send a valid update before the timer expires. A sensor configured to expire after 60 seconds cannot remain available if it reports every five minutes.

    Compare the configured expiry with the real publish interval, including battery-saving sleep. Allow enough margin for Wi-Fi reconnection, broker delays, and normal jitter. Do not reduce battery life by forcing excessive updates merely to satisfy an unnecessarily short expiry.

    Step 7: Look for stale or duplicate discovery configurations

    If the same physical device has multiple entities or old names, search the broker’s retained discovery topics for obsolete configurations. A changed unique_id, discovery topic, or device identifier can create a second entity instead of updating the first.

    Remove only a configuration you have positively identified. The standard discovery removal method is to publish an empty retained payload to the exact obsolete configuration topic. Before doing so, save the topic and payload so you can restore it. Never bulk-delete retained messages as a first troubleshooting step.

    How to verify the fix

    1. Restart Home Assistant once; do not restart the MQTT device at the same time.
    2. Confirm the broker connection returns normally.
    3. Watch for the Home Assistant birth message.
    4. Confirm discovery is replayed or delivered from retained storage.
    5. Confirm the current availability message is received.
    6. Confirm a fresh state arrives and the entity becomes available.
    7. Wait longer than the previous failure interval to ensure it stays available.

    Rollback and recovery

    If a configuration change makes the problem worse, restore the saved discovery payload, return the previous retain settings, and restart only the affected publisher. If you edited YAML, restore the backup and validate configuration before restarting Home Assistant. If many devices fail simultaneously, investigate the broker, credentials, DNS, firewall, storage, or MQTT integration rather than resetting every endpoint.

    When to escalate

    Collect the Home Assistant version, installation type, MQTT integration diagnostics, broker version, exact affected topics with secrets removed, timestamps, and a short sequence that reproduces the failure. Report firmware-specific behavior to the device or bridge project. Never post broker passwords, access tokens, private certificates, or complete diagnostics without reviewing them for sensitive information.

    Prevention

    • Make discovery publishers respond to the Home Assistant birth message.
    • Retain discovery configurations and availability status where the publisher supports it correctly.
    • Use stable unique IDs and topic names.
    • Document state, availability, and expiry behavior separately.
    • Back up broker configuration and custom publisher code.
    • Test one controlled Home Assistant restart after firmware or broker changes.

    Use a controlled message trace to prove which stage fails

    When several MQTT entities behave differently, capture a short, time-bounded trace for one affected device. Begin listening before restarting Home Assistant, note the timestamp of the birth message, and then record the order in which discovery, availability, and state messages arrive. Remove credentials and sensitive payload fields before saving or sharing the trace.

    The sequence matters. If discovery arrives but availability never follows, investigate the publisher’s connection and Last Will configuration. If availability arrives but state does not, examine the device’s publish interval, sleeping behavior, and state topic. If no discovery arrives until the device restarts, the birth-message subscription or retained discovery configuration is the likely gap. A trace converts a vague “unavailable” symptom into a specific missing message.

    Special considerations for sleeping and battery-powered devices

    A sleeping sensor may not respond immediately to a Home Assistant restart. Its state and availability design should reflect the expected wake interval. Do not force a battery device to remain awake or publish excessively simply to make the interface update sooner. Compare the configured expiration period with the longest normal sleep interval, including weak-signal retries and seasonal reporting behavior.

    Some publishers intentionally omit an availability topic and rely on the age of the last state. Others use a bridge-level availability topic shared by many child devices. Identify the model actually implemented before changing retain flags. Applying a generic online/offline pattern to a sleeping product can mark a healthy device unavailable between reports.

    Broker-session and permission checks

    After credentials, TLS settings, or access-control lists change, a publisher may connect but lose permission to publish discovery or availability topics. Review broker logs for denied subscriptions or publishes, using the exact client ID and topic. Also check for duplicate client IDs: MQTT brokers normally disconnect the earlier session when another client connects with the same identifier, which can create a repeating online/offline pattern.

    Make one reversible change at a time. Correct the topic permission or client ID, reconnect the publisher, and repeat the controlled trace. Avoid broad wildcard permissions as a shortcut; grant only the topic access the device or bridge requires.

    What to include when escalating

    Provide the broker version, Home Assistant version and installation type, publisher firmware, discovery prefix, redacted topic names, QoS and retain settings, availability mode, expiry configuration, and a timestamped message sequence. State whether reloading MQTT, restarting Home Assistant, or restarting the publisher changes the outcome. Keep broker passwords, certificates, access tokens, unique device identifiers, and complete unredacted payloads private.

    Evidence and testing disclosure

    Applies to: current Home Assistant MQTT discovery and manually configured MQTT entities, including publishers that use birth messages, availability topics, retained configuration, or expire_after. Expected result: after Home Assistant restarts, the broker reconnects, discovery is replayed or retained, the current availability arrives, and a fresh state restores the entity without restarting the physical device. Verification: capture one time-bounded trace in the order birth → discovery → availability → state. Rollback: restore saved topic payloads and previous retain or expiry settings if a change fails. Testing status: this guide follows official Home Assistant MQTT behavior; Troubliq did not test every third-party publisher. Last reviewed September 30, 2026.

    Sources

    Last reviewed: September 8, 2026.

    Related Troubliq guides: Start with the safe diagnostic method and browse all troubleshooting guides.

    Decision guide: what should be retained?

    Retain the discovery configuration when the device should be reconstructed automatically after Home Assistant reconnects. Retain the latest availability status when subscribers need to know immediately whether the device is online, and configure Last Will and Testament so an unexpected disconnect leaves an accurate offline status. Treat state retention as a separate design choice.

    For a temperature, energy total, or other slowly changing measurement, a retained state can be reasonable when users understand its timestamp and no conflicting expiry logic exists. For motion, button presses, doorbell events, and commands, a retained state can replay an old event as though it just happened and is usually unsafe. For sensors using expire_after, follow the official warning about retained state and test restart behavior carefully.

    If you do not control the publisher, do not compensate with broad broker cleanup. Document the exact topics, capture a short message trace, and report the missing discovery replay or availability behavior to the device project. A precise report is more useful than repeatedly reloading the integration.

    Find your next troubleshooting path

    Use the related guide that matches the next confirmed layer of the failure. Avoid changing unrelated systems at the same time.