diff --git a/esphome/components/speaker/media_player/speaker_media_player.cpp b/esphome/components/speaker/media_player/speaker_media_player.cpp
index e4aa78d10d..8ab4128e92 100644
--- a/esphome/components/speaker/media_player/speaker_media_player.cpp
+++ b/esphome/components/speaker/media_player/speaker_media_player.cpp
@@ -52,6 +52,11 @@ static const UBaseType_t ANNOUNCEMENT_PIPELINE_TASK_PRIORITY = 1;
 
 ESPHOME_LOG_TAG(TAG, "speaker_media_player");
 
+static constexpr uint32_t UNPAUSE_MEDIA_INTERVAL_ID = 0;
+static constexpr uint32_t NEXT_ANNOUNCEMENT_TIMEOUT_ID = 1;
+static constexpr uint32_t NEXT_MEDIA_TIMEOUT_ID = 2;
+static constexpr uint32_t UNPAUSE_ANNOUNCEMENT_INTERVAL_ID = 3;
+
 void SpeakerMediaPlayer::setup() {
 #ifdef USE_SPEAKER_MEDIA_PLAYER_ON_OFF
   state = media_player::MEDIA_PLAYER_STATE_OFF;
@@ -112,13 +117,13 @@ void SpeakerMediaPlayer::set_playlist_delay_ms(AudioPipelineType pipeline_type,
 void SpeakerMediaPlayer::stop_and_unpause_media_() {
   this->media_pipeline_->stop();
   this->unpause_media_remaining_ = 3;
-  this->set_interval("unpause_med", 50, [this]() {
+  this->set_interval(UNPAUSE_MEDIA_INTERVAL_ID, 50, [this]() {
     if (this->media_pipeline_state_ == AudioPipelineState::STOPPED) {
-      this->cancel_interval("unpause_med");
+      this->cancel_interval(UNPAUSE_MEDIA_INTERVAL_ID);
       this->media_pipeline_->set_pause_state(false);
       this->is_paused_ = false;
     } else if (--this->unpause_media_remaining_ == 0) {
-      this->cancel_interval("unpause_med");
+      this->cancel_interval(UNPAUSE_MEDIA_INTERVAL_ID);
     }
   });
 }
@@ -152,7 +157,7 @@ void SpeakerMediaPlayer::watch_media_commands_() {
       if (this->single_pipeline_() || (media_command.announce.has_value() && media_command.announce.value())) {
         if (!enqueue) {
           // Ensure the loaded next item doesn't start playing, clear the queue, start the file, and unpause
-          this->cancel_timeout("next_ann");
+          this->cancel_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID);
           this->announcement_playlist_.clear();
           this->announcement_item_failed_ = false;
           if (media_command.file.has_value()) {
@@ -166,7 +171,7 @@ void SpeakerMediaPlayer::watch_media_commands_() {
       } else {
         if (!enqueue) {
           // Ensure the loaded next item doesn't start playing, clear the queue, start the file, and unpause
-          this->cancel_timeout("next_media");
+          this->cancel_timeout(NEXT_MEDIA_TIMEOUT_ID);
           this->media_playlist_.clear();
           this->media_item_failed_ = false;
           if (this->is_paused_) {
@@ -236,23 +241,23 @@ void SpeakerMediaPlayer::watch_media_commands_() {
           if (this->single_pipeline_() || (media_command.announce.has_value() && media_command.announce.value())) {
 #endif
             if (this->announcement_pipeline_ != nullptr) {
-              this->cancel_timeout("next_ann");
+              this->cancel_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID);
               this->announcement_playlist_.clear();
               this->announcement_item_failed_ = false;
               this->announcement_pipeline_->stop();
               this->unpause_announcement_remaining_ = 3;
-              this->set_interval("unpause_ann", 50, [this]() {
+              this->set_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID, 50, [this]() {
                 if (this->announcement_pipeline_state_ == AudioPipelineState::STOPPED) {
-                  this->cancel_interval("unpause_ann");
+                  this->cancel_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID);
                   this->announcement_pipeline_->set_pause_state(false);
                 } else if (--this->unpause_announcement_remaining_ == 0) {
-                  this->cancel_interval("unpause_ann");
+                  this->cancel_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID);
                 }
               });
             }
           } else {
             if (this->media_pipeline_ != nullptr) {
-              this->cancel_timeout("next_media");
+              this->cancel_timeout(NEXT_MEDIA_TIMEOUT_ID);
               this->media_playlist_.clear();
               this->media_item_failed_ = false;
               this->stop_and_unpause_media_();
@@ -408,7 +413,8 @@ void SpeakerMediaPlayer::loop() {
           this->announcement_pipeline_->set_pause_state(true);
           // Internally unpause the pipeline after the delay between playlist items. Announcements do not follow the
           // media player's pause state.
-          this->set_timeout("next_ann", timeout_ms, [this]() { this->announcement_pipeline_->set_pause_state(false); });
+          this->set_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID, timeout_ms,
+                            [this]() { this->announcement_pipeline_->set_pause_state(false); });
         }
       }
     } else {
@@ -454,7 +460,7 @@ void SpeakerMediaPlayer::loop() {
               this->media_pipeline_->set_pause_state(true);
               // Internally unpause the pipeline after the delay between playlist items, if the media player state is
               // not paused.
-              this->set_timeout("next_media", timeout_ms,
+              this->set_timeout(NEXT_MEDIA_TIMEOUT_ID, timeout_ms,
                                 [this]() { this->media_pipeline_->set_pause_state(this->is_paused_); });
             }
           }
diff --git a/esphome/components/voice_assistant/voice_assistant.cpp b/esphome/components/voice_assistant/voice_assistant.cpp
index e952308437..039410abdb 100644
--- a/esphome/components/voice_assistant/voice_assistant.cpp
+++ b/esphome/components/voice_assistant/voice_assistant.cpp
@@ -14,6 +14,11 @@ namespace esphome::voice_assistant {
 
 ESPHOME_LOG_TAG(TAG, "voice_assistant");
 
+static constexpr uint32_t RESET_CONVERSATION_TIMEOUT_ID = 0;
+static constexpr uint32_t PLAYBACK_TIMEOUT_ID = 1;
+static constexpr uint32_t SPEAKER_IDLE_TIMEOUT_ID = 2;
+static constexpr uint32_t TIMER_TICK_INTERVAL_ID = 3;
+
 #ifdef SAMPLE_RATE_HZ
 #undef SAMPLE_RATE_HZ
 #endif
@@ -370,7 +375,7 @@ void VoiceAssistant::loop() {
         break;
       }
       this->set_state_(State::STARTING_PIPELINE);
-      this->set_timeout("reset-conversation_id", this->conversation_timeout_,
+      this->set_timeout(RESET_CONVERSATION_TIMEOUT_ID, this->conversation_timeout_,
                         [this]() { this->reset_conversation_id(); });
       break;
     }
@@ -460,10 +465,10 @@ void VoiceAssistant::loop() {
         if (this->speaker_bytes_received_ > RECEIVE_SIZE * 4 || end_of_stream)
           this->write_speaker_();
         if (this->wait_for_stream_end_) {
-          this->cancel_timeout("playing");
+          this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
           if (end_of_stream) {
             ESP_LOGD(TAG, "End of audio stream received");
-            this->cancel_timeout("speaker-timeout");
+            this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
             this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
           }
           break;  // We dont want to timeout here as the STREAM_END event will take care of that.
@@ -477,7 +482,7 @@ void VoiceAssistant::loop() {
 
         if (this->media_player_response_state_ == MediaPlayerResponseState::FINISHED) {
           this->media_player_response_state_ = MediaPlayerResponseState::IDLE;
-          this->cancel_timeout("playing");
+          this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
           ESP_LOGD(TAG, "Announcement finished playing");
           this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
 
@@ -507,8 +512,8 @@ void VoiceAssistant::loop() {
         }
         ESP_LOGD(TAG, "Speaker has finished outputting all audio");
         this->speaker_->stop();
-        this->cancel_timeout("speaker-timeout");
-        this->cancel_timeout("playing");
+        this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
+        this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
 
         this->clear_buffers_();
 
@@ -540,7 +545,7 @@ void VoiceAssistant::write_speaker_() {
         memmove(this->speaker_buffer_, this->speaker_buffer_ + written, this->speaker_buffer_size_ - written);
         this->speaker_buffer_size_ -= written;
         this->speaker_buffer_index_ -= written;
-        this->set_timeout("speaker-timeout", 5000, [this]() { this->speaker_->stop(); });
+        this->set_timeout(SPEAKER_IDLE_TIMEOUT_ID, 5000, [this]() { this->speaker_->stop(); });
       } else {
         ESP_LOGV(TAG, "Speaker buffer full, trying again next loop");
       }
@@ -755,8 +760,8 @@ void VoiceAssistant::signal_stop_() {
 }
 
 void VoiceAssistant::start_playback_timeout_() {
-  this->set_timeout("playing", 2000, [this]() {
-    this->cancel_timeout("speaker-timeout");
+  this->set_timeout(PLAYBACK_TIMEOUT_ID, 2000, [this]() {
+    this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
     this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
 
     if (this->api_client_ == nullptr)
@@ -1046,10 +1051,10 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
   }
 
   if (this->timers_.empty()) {
-    this->cancel_interval("timer-event");
+    this->cancel_interval(TIMER_TICK_INTERVAL_ID);
     this->timer_tick_running_ = false;
   } else if (!this->timer_tick_running_) {
-    this->set_interval("timer-event", 1000, [this]() { this->timer_tick_(); });
+    this->set_interval(TIMER_TICK_INTERVAL_ID, 1000, [this]() { this->timer_tick_(); });
     this->timer_tick_running_ = true;
   }
 }
diff --git a/esphome/components/xiaomi_mue4094rt/xiaomi_mue4094rt.cpp b/esphome/components/xiaomi_mue4094rt/xiaomi_mue4094rt.cpp
index afd8715ec5..683e8a2a92 100644
--- a/esphome/components/xiaomi_mue4094rt/xiaomi_mue4094rt.cpp
+++ b/esphome/components/xiaomi_mue4094rt/xiaomi_mue4094rt.cpp
@@ -5,6 +5,8 @@ namespace esphome::xiaomi_mue4094rt {
 
 ESPHOME_LOG_TAG(TAG, "xiaomi_mue4094rt");
 
+static constexpr uint32_t MOTION_TIMEOUT_ID = 0;
+
 void XiaomiMUE4094RT::dump_config() {
   ESP_LOGCONFIG(TAG, "Xiaomi MUE4094RT");
   LOG_BINARY_SENSOR("  ", "Motion", this);
@@ -40,7 +42,7 @@ bool XiaomiMUE4094RT::parse_device(const ble_device_base::ESPBTDevice &device) {
     }
     if (res->has_motion.has_value()) {
       this->publish_state(*res->has_motion);
-      this->set_timeout("motion_timeout", timeout_, [this]() { this->publish_state(false); });
+      this->set_timeout(MOTION_TIMEOUT_ID, timeout_, [this]() { this->publish_state(false); });
     }
     success = true;
   }
diff --git a/esphome/components/xiaomi_rtcgq02lm/xiaomi_rtcgq02lm.cpp b/esphome/components/xiaomi_rtcgq02lm/xiaomi_rtcgq02lm.cpp
index 8bf098a676..f7ecf15c3b 100644
--- a/esphome/components/xiaomi_rtcgq02lm/xiaomi_rtcgq02lm.cpp
+++ b/esphome/components/xiaomi_rtcgq02lm/xiaomi_rtcgq02lm.cpp
@@ -6,6 +6,9 @@ namespace esphome::xiaomi_rtcgq02lm {
 
 ESPHOME_LOG_TAG(TAG, "xiaomi_rtcgq02lm");
 
+static constexpr uint32_t MOTION_TIMEOUT_ID = 0;
+static constexpr uint32_t BUTTON_TIMEOUT_ID = 1;
+
 static constexpr size_t RTCGQ02LM_BINDKEY_SIZE = 16;
 
 void XiaomiRTCGQ02LM::dump_config() {
@@ -55,13 +58,13 @@ bool XiaomiRTCGQ02LM::parse_device(const ble_device_base::ESPBTDevice &device) {
 #ifdef USE_BINARY_SENSOR
     if (res->has_motion.has_value() && this->motion_ != nullptr) {
       this->motion_->publish_state(*res->has_motion);
-      this->set_timeout("motion_timeout", this->motion_timeout_, [this]() { this->motion_->publish_state(false); });
+      this->set_timeout(MOTION_TIMEOUT_ID, this->motion_timeout_, [this]() { this->motion_->publish_state(false); });
     }
     if (res->is_light.has_value() && this->light_ != nullptr)
       this->light_->publish_state(*res->is_light);
     if (res->button_press.has_value() && this->button_ != nullptr) {
       this->button_->publish_state(*res->button_press);
-      this->set_timeout("button_timeout", this->button_timeout_, [this]() { this->button_->publish_state(false); });
+      this->set_timeout(BUTTON_TIMEOUT_ID, this->button_timeout_, [this]() { this->button_->publish_state(false); });
     }
 #endif
 #ifdef USE_SENSOR
diff --git a/esphome/components/zigbee/time/zigbee_time_esp32.cpp b/esphome/components/zigbee/time/zigbee_time_esp32.cpp
index a6a25ef2f3..1bc0923a1f 100644
--- a/esphome/components/zigbee/time/zigbee_time_esp32.cpp
+++ b/esphome/components/zigbee/time/zigbee_time_esp32.cpp
@@ -7,6 +7,9 @@ namespace esphome::zigbee {
 
 ESPHOME_LOG_TAG(TAG, "zigbee.time");
 
+static constexpr uint32_t REGISTER_RETRY_TIMEOUT_ID = 0;
+static constexpr uint32_t SYNC_RETRY_TIMEOUT_ID = 1;
+
 // This time standard is the number of
 // seconds since 0 hrs 0 mins 0 sec on 1st January 2000 UTC (Universal Coordinated Time).
 constexpr time_t EPOCH_2000 = 946684800;
@@ -29,7 +32,7 @@ void ZigbeeTime::register_zb_time_() {
   };
   ezb_err_t ret;
   if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
-    this->set_timeout("zb_time_register", 100, [this]() { this->register_zb_time_(); });
+    this->set_timeout(REGISTER_RETRY_TIMEOUT_ID, 100, [this]() { this->register_zb_time_(); });
     return;
   }
   ret = ezb_zcl_time_server_interface_register(this->endpoint_, time_interface);
@@ -69,7 +72,7 @@ void ZigbeeTime::update() {
         ESP_LOGW(TAG, "Could not acquire Zigbee lock to synchronize time, will retry maximum 3 times");
       }
       if (this->retry_count_ < 3) {
-        this->set_timeout("zb_time_sync", 100, [this]() { this->update(); });
+        this->set_timeout(SYNC_RETRY_TIMEOUT_ID, 100, [this]() { this->update(); });
         this->retry_count_++;
       } else {
         ESP_LOGW(TAG, "Could not acquire Zigbee lock to synchronize time");
diff --git a/esphome/components/zigbee/zigbee_esp32.cpp b/esphome/components/zigbee/zigbee_esp32.cpp
index 676407d751..8b7b59acb0 100644
--- a/esphome/components/zigbee/zigbee_esp32.cpp
+++ b/esphome/components/zigbee/zigbee_esp32.cpp
@@ -19,6 +19,8 @@ namespace esphome::zigbee {
 
 ESPHOME_LOG_TAG(TAG, "zigbee");
 
+static constexpr uint32_t COMMISSIONING_RETRY_TIMEOUT_ID = 0;
+
 static ZigbeeComponent *global_zigbee = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 uint8_t *get_zcl_string(const char *str, uint8_t max_size, bool use_max_size) {
@@ -49,7 +51,8 @@ void ZigbeeComponent::factory_reset() {
 
 void ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode) {
   if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
-    global_zigbee->set_timeout("zb_init", 100, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
+    global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 100,
+                               [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
     App.wake_loop_threadsafe();
     return;
   }
@@ -86,7 +89,7 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
         }
       } else {
         ESP_LOGW(TAG, "The %s failed with status(0x%02x), please retry", ezb_app_signal_to_string(signal_type), status);
-        global_zigbee->set_timeout("zb_init", 1000, []() {
+        global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
           ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_INITIALIZATION);
         });
         App.wake_loop_threadsafe();
@@ -107,11 +110,11 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
         ESP_LOGD(TAG, "Failed to join network with status(0x%02x)", status);
         if (steering_retry_count < 10) {
           steering_retry_count++;
-          global_zigbee->set_timeout("zb_init", 1000, []() {
+          global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
             ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
           });
         } else {
-          global_zigbee->set_timeout("zb_init", 600 * 1000, []() {
+          global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 600 * 1000, []() {
             ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
           });
         }