diff --git a/CODEOWNERS b/CODEOWNERS
index 3e82a372ce..d5ce5e6920 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -88,6 +88,7 @@ esphome/components/honeywellabp/* @RubyBailey
 esphome/components/hrxl_maxsonar_wr/* @netmikey
 esphome/components/hydreon_rgxx/* @functionpointer
 esphome/components/i2c/* @esphome/core
+esphome/components/i2s_audio/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina260/* @MrEditor97
 esphome/components/inkbird_ibsth1_mini/* @fkirill
@@ -119,6 +120,7 @@ esphome/components/mcp47a1/* @jesserockz
 esphome/components/mcp9808/* @k7hpn
 esphome/components/md5/* @esphome/core
 esphome/components/mdns/* @esphome/core
+esphome/components/media_player/* @jesserockz
 esphome/components/midea/* @dudanov
 esphome/components/midea_ir/* @dudanov
 esphome/components/mitsubishi/* @RubyBailey
diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index bd39893825..3e9a62f3d8 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -42,6 +42,7 @@ service APIConnection {
   rpc select_command (SelectCommandRequest) returns (void) {}
   rpc button_command (ButtonCommandRequest) returns (void) {}
   rpc lock_command (LockCommandRequest) returns (void) {}
+  rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
 }
 
 
@@ -991,7 +992,7 @@ message ListEntitiesLockResponse {
   bool supports_open = 9;
   bool requires_code = 10;
 
-  # Not yet implemented:
+  // Not yet implemented:
   string code_format = 11;
 }
 message LockStateResponse {
@@ -1010,7 +1011,7 @@ message LockCommandRequest {
   fixed32 key = 1;
   LockCommand command = 2;
 
-  # Not yet implemented:
+  // Not yet implemented:
   bool has_code = 3;
   string code = 4;
 }
@@ -1040,3 +1041,60 @@ message ButtonCommandRequest {
   fixed32 key = 1;
 }
 
+// ==================== MEDIA PLAYER ====================
+enum MediaPlayerState {
+  MEDIA_PLAYER_STATE_NONE = 0;
+  MEDIA_PLAYER_STATE_IDLE = 1;
+  MEDIA_PLAYER_STATE_PLAYING = 2;
+  MEDIA_PLAYER_STATE_PAUSED = 3;
+}
+enum MediaPlayerCommand {
+  MEDIA_PLAYER_COMMAND_PLAY = 0;
+  MEDIA_PLAYER_COMMAND_PAUSE = 1;
+  MEDIA_PLAYER_COMMAND_STOP = 2;
+  MEDIA_PLAYER_COMMAND_MUTE = 3;
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4;
+}
+message ListEntitiesMediaPlayerResponse {
+  option (id) = 63;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+
+  bool supports_pause = 8;
+}
+message MediaPlayerStateResponse {
+  option (id) = 64;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  MediaPlayerState state = 2;
+  float volume = 3;
+  bool muted = 4;
+}
+message MediaPlayerCommandRequest {
+  option (id) = 65;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+
+  bool has_command = 2;
+  MediaPlayerCommand command = 3;
+
+  bool has_volume = 4;
+  float volume = 5;
+
+  bool has_media_url = 6;
+  string media_url = 7;
+}
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 4f399d95d0..9028034c90 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -733,6 +733,52 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
+  if (!this->state_subscription_)
+    return false;
+
+  MediaPlayerStateResponse resp{};
+  resp.key = media_player->get_object_id_hash();
+  resp.state = static_cast<enums::MediaPlayerState>(media_player->state);
+  resp.volume = media_player->volume;
+  resp.muted = media_player->is_muted();
+  return this->send_media_player_state_response(resp);
+}
+bool APIConnection::send_media_player_info(media_player::MediaPlayer *media_player) {
+  ListEntitiesMediaPlayerResponse msg;
+  msg.key = media_player->get_object_id_hash();
+  msg.object_id = media_player->get_object_id();
+  msg.name = media_player->get_name();
+  msg.unique_id = get_default_unique_id("media_player", media_player);
+  msg.icon = media_player->get_icon();
+  msg.disabled_by_default = media_player->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(media_player->get_entity_category());
+
+  auto traits = media_player->get_traits();
+  msg.supports_pause = traits.get_supports_pause();
+
+  return this->send_list_entities_media_player_response(msg);
+}
+void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
+  media_player::MediaPlayer *media_player = App.get_media_player_by_key(msg.key);
+  if (media_player == nullptr)
+    return;
+
+  auto call = media_player->make_call();
+  if (msg.has_command) {
+    call.set_command(static_cast<media_player::MediaPlayerCommand>(msg.command));
+  }
+  if (msg.has_volume) {
+    call.set_volume(msg.volume);
+  }
+  if (msg.has_media_url) {
+    call.set_media_url(msg.media_url);
+  }
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 10f0becc54..0787d2f7eb 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -82,6 +82,11 @@ class APIConnection : public APIServerConnection {
   bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
   bool send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state(media_player::MediaPlayer *media_player);
+  bool send_media_player_info(media_player::MediaPlayer *media_player);
+  void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 5a78587473..70f909c07a 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -308,6 +308,36 @@ template<> const char *proto_enum_to_string<enums::LockCommand>(enums::LockComma
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::MediaPlayerState>(enums::MediaPlayerState value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_STATE_NONE:
+      return "MEDIA_PLAYER_STATE_NONE";
+    case enums::MEDIA_PLAYER_STATE_IDLE:
+      return "MEDIA_PLAYER_STATE_IDLE";
+    case enums::MEDIA_PLAYER_STATE_PLAYING:
+      return "MEDIA_PLAYER_STATE_PLAYING";
+    case enums::MEDIA_PLAYER_STATE_PAUSED:
+      return "MEDIA_PLAYER_STATE_PAUSED";
+    default:
+      return "UNKNOWN";
+  }
+}
+template<> const char *proto_enum_to_string<enums::MediaPlayerCommand>(enums::MediaPlayerCommand value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_COMMAND_PLAY:
+      return "MEDIA_PLAYER_COMMAND_PLAY";
+    case enums::MEDIA_PLAYER_COMMAND_PAUSE:
+      return "MEDIA_PLAYER_COMMAND_PAUSE";
+    case enums::MEDIA_PLAYER_COMMAND_STOP:
+      return "MEDIA_PLAYER_COMMAND_STOP";
+    case enums::MEDIA_PLAYER_COMMAND_MUTE:
+      return "MEDIA_PLAYER_COMMAND_MUTE";
+    case enums::MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "MEDIA_PLAYER_COMMAND_UNMUTE";
+    default:
+      return "UNKNOWN";
+  }
+}
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -4574,6 +4604,254 @@ void ButtonCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesMediaPlayerResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    case 8: {
+      this->supports_pause = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_bool(8, this->supports_pause);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesMediaPlayerResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  supports_pause: ");
+  out.append(YESNO(this->supports_pause));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_enum<enums::MediaPlayerState>();
+      return true;
+    }
+    case 4: {
+      this->muted = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 3: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_enum<enums::MediaPlayerState>(2, this->state);
+  buffer.encode_float(3, this->volume);
+  buffer.encode_bool(4, this->muted);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerState>(this->state));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  muted: ");
+  out.append(YESNO(this->muted));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->has_command = value.as_bool();
+      return true;
+    }
+    case 3: {
+      this->command = value.as_enum<enums::MediaPlayerCommand>();
+      return true;
+    }
+    case 4: {
+      this->has_volume = value.as_bool();
+      return true;
+    }
+    case 6: {
+      this->has_media_url = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 7: {
+      this->media_url = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 5: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->has_command);
+  buffer.encode_enum<enums::MediaPlayerCommand>(3, this->command);
+  buffer.encode_bool(4, this->has_volume);
+  buffer.encode_float(5, this->volume);
+  buffer.encode_bool(6, this->has_media_url);
+  buffer.encode_string(7, this->media_url);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_command: ");
+  out.append(YESNO(this->has_command));
+  out.append("\n");
+
+  out.append("  command: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerCommand>(this->command));
+  out.append("\n");
+
+  out.append("  has_volume: ");
+  out.append(YESNO(this->has_volume));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_media_url: ");
+  out.append(YESNO(this->has_media_url));
+  out.append("\n");
+
+  out.append("  media_url: ");
+  out.append("'").append(this->media_url).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 28c0a7ce88..ec1cdc35ac 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -141,6 +141,19 @@ enum LockCommand : uint32_t {
   LOCK_LOCK = 1,
   LOCK_OPEN = 2,
 };
+enum MediaPlayerState : uint32_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3,
+};
+enum MediaPlayerCommand : uint32_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+};
 
 }  // namespace enums
 
@@ -1146,6 +1159,60 @@ class ButtonCommandRequest : public ProtoMessage {
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
 };
+class ListEntitiesMediaPlayerResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  bool supports_pause{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::MediaPlayerState state{};
+  float volume{0.0f};
+  bool muted{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_command{false};
+  enums::MediaPlayerCommand command{};
+  bool has_volume{false};
+  float volume{0.0f};
+  bool has_media_url{false};
+  std::string media_url{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index d981a3bf4e..bd146cb54d 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -310,6 +310,24 @@ bool APIServerConnectionBase::send_list_entities_button_response(const ListEntit
 #endif
 #ifdef USE_BUTTON
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_media_player_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesMediaPlayerResponse>(msg, 63);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_media_player_state_response(const MediaPlayerStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_media_player_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<MediaPlayerStateResponse>(msg, 64);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -563,6 +581,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
+#endif
+      break;
+    }
+    case 65: {
+#ifdef USE_MEDIA_PLAYER
+      MediaPlayerCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_media_player_command_request(msg);
 #endif
       break;
     }
@@ -813,6 +842,19 @@ void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg)
   this->lock_command(msg);
 }
 #endif
+#ifdef USE_MEDIA_PLAYER
+void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->media_player_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 5aaf831c91..28ad3fbd15 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -144,6 +144,15 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_BUTTON
   virtual void on_button_command_request(const ButtonCommandRequest &value){};
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state_response(const MediaPlayerStateResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -192,6 +201,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_LOCK
   virtual void lock_command(const LockCommandRequest &msg) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -236,6 +248,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_LOCK
   void on_lock_command_request(const LockCommandRequest &msg) override;
 #endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api
diff --git a/esphome/components/api/api_server.cpp b/esphome/components/api/api_server.cpp
index 1f2800f298..8375a82313 100644
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@@ -272,6 +272,15 @@ void APIServer::on_lock_update(lock::Lock *obj) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_media_player_state(obj);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index f03a83fc7b..6997e23cac 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -68,6 +68,9 @@ class APIServer : public Component, public Controller {
 #endif
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
diff --git a/esphome/components/api/list_entities.cpp b/esphome/components/api/list_entities.cpp
index 9f55fda617..85d4cd61ef 100644
--- a/esphome/components/api/list_entities.cpp
+++ b/esphome/components/api/list_entities.cpp
@@ -64,5 +64,11 @@ bool ListEntitiesIterator::on_number(number::Number *number) { return this->clie
 bool ListEntitiesIterator::on_select(select::Select *select) { return this->client_->send_select_info(select); }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool ListEntitiesIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_info(media_player);
+}
+#endif
+
 }  // namespace api
 }  // namespace esphome
diff --git a/esphome/components/api/list_entities.h b/esphome/components/api/list_entities.h
index 51c343eb03..4fbaa509a2 100644
--- a/esphome/components/api/list_entities.h
+++ b/esphome/components/api/list_entities.h
@@ -51,6 +51,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
   bool on_end() override;
 
diff --git a/esphome/components/api/subscribe_state.cpp b/esphome/components/api/subscribe_state.cpp
index ba277502c8..1d1ba0245e 100644
--- a/esphome/components/api/subscribe_state.cpp
+++ b/esphome/components/api/subscribe_state.cpp
@@ -50,6 +50,11 @@ bool InitialStateIterator::on_select(select::Select *select) {
 #ifdef USE_LOCK
 bool InitialStateIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_state(a_lock, a_lock->state); }
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool InitialStateIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_state(media_player);
+}
+#endif
 InitialStateIterator::InitialStateIterator(APIConnection *client) : client_(client) {}
 
 }  // namespace api
diff --git a/esphome/components/api/subscribe_state.h b/esphome/components/api/subscribe_state.h
index 515e1a2d07..7a7ba697c0 100644
--- a/esphome/components/api/subscribe_state.h
+++ b/esphome/components/api/subscribe_state.h
@@ -48,6 +48,9 @@ class InitialStateIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
  protected:
   APIConnection *client_;
diff --git a/esphome/components/i2s_audio/__init__.py b/esphome/components/i2s_audio/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.cpp b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
new file mode 100644
index 0000000000..0ab3237aeb
--- /dev/null
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.cpp
@@ -0,0 +1,132 @@
+#include "i2s_audio_media_player.h"
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace i2s_audio {
+
+static const char *const TAG = "audio";
+
+void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
+  if (call.get_media_url().has_value()) {
+    if (this->audio_->isRunning())
+      this->audio_->stopSong();
+    this->high_freq_.start();
+    this->audio_->connecttohost(call.get_media_url().value().c_str());
+    this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+  }
+  if (call.get_volume().has_value()) {
+    this->volume = call.get_volume().value();
+    this->set_volume_(volume);
+    this->unmute_();
+  }
+  if (call.get_command().has_value()) {
+    switch (call.get_command().value()) {
+      case media_player::MEDIA_PLAYER_COMMAND_PLAY:
+        if (!this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_PAUSE:
+        if (this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_STOP:
+        this->stop_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_MUTE:
+        this->mute_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_UNMUTE:
+        this->unmute_();
+        break;
+    }
+  }
+  this->publish_state();
+}
+
+void I2SAudioMediaPlayer::mute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(true);
+  } else {
+    this->set_volume_(0.0f, false);
+  }
+  this->muted_ = true;
+}
+void I2SAudioMediaPlayer::unmute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(false);
+  } else {
+    this->set_volume_(this->volume, false);
+  }
+  this->muted_ = false;
+}
+void I2SAudioMediaPlayer::set_volume_(float volume, bool publish) {
+  this->audio_->setVolume(remap<uint8_t, float>(volume, 0.0f, 1.0f, 0, 21));
+  if (publish)
+    this->volume = volume;
+}
+
+void I2SAudioMediaPlayer::stop_() {
+  if (this->audio_->isRunning())
+    this->audio_->stopSong();
+  this->high_freq_.stop();
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Audio...");
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    this->audio_ = make_unique<Audio>(true, this->internal_dac_mode_);
+  } else {
+    this->audio_ = make_unique<Audio>(false);
+    this->audio_->setPinout(this->bclk_pin_, this->lrclk_pin_, this->dout_pin_);
+    this->audio_->forceMono(this->external_dac_channels_ == 1);
+  }
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::loop() {
+  this->audio_->loop();
+  if (this->state == media_player::MEDIA_PLAYER_STATE_PLAYING && !this->audio_->isRunning()) {
+    this->stop_();
+    this->publish_state();
+  }
+}
+
+media_player::MediaPlayerTraits I2SAudioMediaPlayer::get_traits() {
+  auto traits = media_player::MediaPlayerTraits();
+  traits.set_supports_pause(true);
+  return traits;
+};
+
+void I2SAudioMediaPlayer::dump_config() {
+  ESP_LOGCONFIG(TAG, "Audio:");
+  if (this->is_failed()) {
+    ESP_LOGCONFIG(TAG, "Audio failed to initialize!");
+    return;
+  }
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    switch (this->internal_dac_mode_) {
+      case I2S_DAC_CHANNEL_LEFT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left");
+        break;
+      case I2S_DAC_CHANNEL_RIGHT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Right");
+        break;
+      case I2S_DAC_CHANNEL_BOTH_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left & Right");
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO
diff --git a/esphome/components/i2s_audio/i2s_audio_media_player.h b/esphome/components/i2s_audio/i2s_audio_media_player.h
new file mode 100644
index 0000000000..89bd128a33
--- /dev/null
+++ b/esphome/components/i2s_audio/i2s_audio_media_player.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/components/media_player/media_player.h"
+#include "esphome/core/component.h"
+#include "esphome/core/gpio.h"
+#include "esphome/core/helpers.h"
+
+#include <Audio.h>
+
+namespace esphome {
+namespace i2s_audio {
+
+class I2SAudioMediaPlayer : public Component, public media_player::MediaPlayer {
+ public:
+  void setup() override;
+  float get_setup_priority() const override { return esphome::setup_priority::LATE; }
+
+  void loop() override;
+
+  void dump_config() override;
+
+  void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
+  void set_bclk_pin(uint8_t pin) { this->bclk_pin_ = pin; }
+  void set_lrclk_pin(uint8_t pin) { this->lrclk_pin_ = pin; }
+  void set_mute_pin(GPIOPin *mute_pin) { this->mute_pin_ = mute_pin; }
+  void set_internal_dac_mode(i2s_dac_mode_t mode) { this->internal_dac_mode_ = mode; }
+  void set_external_dac_channels(uint8_t channels) { this->external_dac_channels_ = channels; }
+
+  media_player::MediaPlayerTraits get_traits() override;
+
+  bool is_muted() const override { return this->muted_; }
+
+ protected:
+  void control(const media_player::MediaPlayerCall &call) override;
+
+  void mute_();
+  void unmute_();
+  void set_volume_(float volume, bool publish = true);
+  void stop_();
+
+  std::unique_ptr<Audio> audio_;
+
+  uint8_t dout_pin_{0};
+  uint8_t din_pin_{0};
+  uint8_t bclk_pin_;
+  uint8_t lrclk_pin_;
+
+  GPIOPin *mute_pin_{nullptr};
+  bool muted_{false};
+  float unmuted_volume_{0};
+
+  i2s_dac_mode_t internal_dac_mode_{I2S_DAC_CHANNEL_DISABLE};
+  uint8_t external_dac_channels_;
+
+  HighFrequencyLoopRequester high_freq_;
+};
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO
diff --git a/esphome/components/i2s_audio/media_player.py b/esphome/components/i2s_audio/media_player.py
new file mode 100644
index 0000000000..e2bdbe2d88
--- /dev/null
+++ b/esphome/components/i2s_audio/media_player.py
@@ -0,0 +1,94 @@
+import esphome.codegen as cg
+from esphome.components import media_player
+import esphome.config_validation as cv
+
+from esphome import pins
+
+from esphome.const import CONF_ID, CONF_MODE
+from esphome.core import CORE
+
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["esp32"]
+
+i2s_audio_ns = cg.esphome_ns.namespace("i2s_audio")
+
+I2SAudioMediaPlayer = i2s_audio_ns.class_(
+    "I2SAudioMediaPlayer", cg.Component, media_player.MediaPlayer
+)
+
+i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
+
+CONF_I2S_DOUT_PIN = "i2s_dout_pin"
+CONF_I2S_BCLK_PIN = "i2s_bclk_pin"
+CONF_I2S_LRCLK_PIN = "i2s_lrclk_pin"
+CONF_MUTE_PIN = "mute_pin"
+CONF_AUDIO_ID = "audio_id"
+CONF_DAC_TYPE = "dac_type"
+
+INTERNAL_DAC_OPTIONS = {
+    "left": i2s_dac_mode_t.I2S_DAC_CHANNEL_LEFT_EN,
+    "right": i2s_dac_mode_t.I2S_DAC_CHANNEL_RIGHT_EN,
+    "stereo": i2s_dac_mode_t.I2S_DAC_CHANNEL_BOTH_EN,
+}
+
+EXTERNAL_DAC_OPTIONS = ["mono", "stereo"]
+
+CONFIG_SCHEMA = cv.All(
+    cv.typed_schema(
+        {
+            "internal": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(CONF_MODE): cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+            "external": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(
+                        CONF_I2S_DOUT_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_BCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_LRCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Optional(CONF_MUTE_PIN): pins.gpio_output_pin_schema,
+                    cv.Optional(CONF_MODE, default="mono"): cv.one_of(
+                        *EXTERNAL_DAC_OPTIONS, lower=True
+                    ),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+        },
+        key=CONF_DAC_TYPE,
+    ),
+    cv.only_with_arduino,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await media_player.register_media_player(var, config)
+
+    if config[CONF_DAC_TYPE] == "internal":
+        cg.add(var.set_internal_dac_mode(config[CONF_MODE]))
+    else:
+        cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
+        cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))
+        cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
+        if CONF_MUTE_PIN in config:
+            pin = await cg.gpio_pin_expression(config[CONF_MUTE_PIN])
+            cg.add(var.set_mute_pin(pin))
+        cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
+
+    if CORE.is_esp32:
+        cg.add_library("WiFiClientSecure", None)
+        cg.add_library("HTTPClient", None)
+        cg.add_library("esphome/ESP32-audioI2S", "2.1.0")
+        cg.add_build_flag("-DAUDIO_NO_SD_FS")
diff --git a/esphome/components/media_player/__init__.py b/esphome/components/media_player/__init__.py
new file mode 100644
index 0000000000..91cf613ed9
--- /dev/null
+++ b/esphome/components/media_player/__init__.py
@@ -0,0 +1,64 @@
+from esphome import automation
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+from esphome.automation import maybe_simple_id
+from esphome.const import CONF_ID
+from esphome.core import CORE
+from esphome.coroutine import coroutine_with_priority
+from esphome.cpp_helpers import setup_entity
+
+
+CODEOWNERS = ["@jesserockz"]
+
+IS_PLATFORM_COMPONENT = True
+
+media_player_ns = cg.esphome_ns.namespace("media_player")
+
+MediaPlayer = media_player_ns.class_("MediaPlayer")
+
+PlayAction = media_player_ns.class_(
+    "PlayAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+PauseAction = media_player_ns.class_(
+    "PauseAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+StopAction = media_player_ns.class_(
+    "StopAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+
+
+async def setup_media_player_core_(var, config):
+    await setup_entity(var, config)
+
+
+async def register_media_player(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_media_player(var))
+    await setup_media_player_core_(var, config)
+
+
+MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.Schema({}))
+
+
+MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id()(
+    {cv.Required(CONF_ID): cv.use_id(MediaPlayer)}
+)
+
+
+@automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.pause", PauseAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action("media_player.stop", StopAction, MEDIA_PLAYER_ACTION_SCHEMA)
+async def media_player_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@coroutine_with_priority(100.0)
+async def to_code(config):
+    cg.add_global(media_player_ns.using)
+    cg.add_define("USE_MEDIA_PLAYER")
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
new file mode 100644
index 0000000000..00ad31ab18
--- /dev/null
+++ b/esphome/components/media_player/media_player.cpp
@@ -0,0 +1,115 @@
+#include "media_player.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace media_player {
+
+static const char *const TAG = "media_player";
+
+const char *media_player_state_to_string(MediaPlayerState state) {
+  switch (state) {
+    case MEDIA_PLAYER_STATE_IDLE:
+      return "IDLE";
+    case MEDIA_PLAYER_STATE_PLAYING:
+      return "PLAYING";
+    case MEDIA_PLAYER_STATE_PAUSED:
+      return "PAUSED";
+    case MEDIA_PLAYER_STATE_NONE:
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *media_player_command_to_string(MediaPlayerCommand command) {
+  switch (command) {
+    case MEDIA_PLAYER_COMMAND_PLAY:
+      return "PLAY";
+    case MEDIA_PLAYER_COMMAND_PAUSE:
+      return "PAUSE";
+    case MEDIA_PLAYER_COMMAND_STOP:
+      return "STOP";
+    case MEDIA_PLAYER_COMMAND_MUTE:
+      return "MUTE";
+    case MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "UNMUTE";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void MediaPlayerCall::validate_() {
+  if (this->media_url_.has_value()) {
+    if (this->command_.has_value()) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Setting both command and media_url is not needed.");
+      this->command_.reset();
+    }
+  }
+  if (this->volume_.has_value()) {
+    if (this->volume_.value() < 0.0f || this->volume_.value() > 1.0f) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Volume must be between 0.0 and 1.0.");
+      this->volume_.reset();
+    }
+  }
+}
+
+void MediaPlayerCall::perform() {
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  this->validate_();
+  if (this->command_.has_value()) {
+    const char *command_s = media_player_command_to_string(this->command_.value());
+    ESP_LOGD(TAG, "  Command: %s", command_s);
+  }
+  if (this->media_url_.has_value()) {
+    ESP_LOGD(TAG, "  Media URL: %s", this->media_url_.value().c_str());
+  }
+  if (this->volume_.has_value()) {
+    ESP_LOGD(TAG, "  Volume: %.2f", this->volume_.value());
+  }
+  this->parent_->control(*this);
+}
+
+MediaPlayerCall &MediaPlayerCall::set_command(MediaPlayerCommand command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(optional<MediaPlayerCommand> command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
+  if (str_equals_case_insensitive(command, "PLAY")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PLAY);
+  } else if (str_equals_case_insensitive(command, "PAUSE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PAUSE);
+  } else if (str_equals_case_insensitive(command, "STOP")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_STOP);
+  } else if (str_equals_case_insensitive(command, "MUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_MUTE);
+  } else if (str_equals_case_insensitive(command, "UNMUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
+  }
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_media_url(const std::string &media_url) {
+  this->media_url_ = media_url;
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_volume(float volume) {
+  this->volume_ = volume;
+  return *this;
+}
+
+void MediaPlayer::add_on_state_callback(std::function<void()> &&callback) {
+  this->state_callback_.add(std::move(callback));
+}
+uint32_t MediaPlayer::hash_base() { return 1938496157UL; }
+
+void MediaPlayer::publish_state() { this->state_callback_.call(); }
+
+}  // namespace media_player
+}  // namespace esphome
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
new file mode 100644
index 0000000000..9a86874996
--- /dev/null
+++ b/esphome/components/media_player/media_player.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace media_player {
+
+enum MediaPlayerState : uint8_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3
+};
+const char *media_player_state_to_string(MediaPlayerState state);
+
+enum MediaPlayerCommand : uint8_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4
+};
+const char *media_player_command_to_string(MediaPlayerCommand command);
+
+class MediaPlayer;
+
+class MediaPlayerTraits {
+ public:
+  MediaPlayerTraits() = default;
+
+  void set_supports_pause(bool supports_pause) { this->supports_pause_ = supports_pause; }
+
+  bool get_supports_pause() const { return this->supports_pause_; }
+
+ protected:
+  bool supports_pause_{false};
+};
+
+class MediaPlayerCall {
+ public:
+  MediaPlayerCall(MediaPlayer *parent) : parent_(parent) {}
+
+  MediaPlayerCall &set_command(MediaPlayerCommand command);
+  MediaPlayerCall &set_command(optional<MediaPlayerCommand> command);
+  MediaPlayerCall &set_command(const std::string &command);
+
+  MediaPlayerCall &set_media_url(const std::string &url);
+
+  MediaPlayerCall &set_volume(float volume);
+
+  void perform();
+
+  const optional<MediaPlayerCommand> &get_command() const { return command_; }
+  const optional<std::string> &get_media_url() const { return media_url_; }
+  const optional<float> &get_volume() const { return volume_; }
+
+ protected:
+  void validate_();
+  MediaPlayer *const parent_;
+  optional<MediaPlayerCommand> command_;
+  optional<std::string> media_url_;
+  optional<float> volume_;
+};
+
+class MediaPlayer : public EntityBase {
+ public:
+  MediaPlayerState state{MEDIA_PLAYER_STATE_NONE};
+  float volume{1.0f};
+
+  MediaPlayerCall make_call() { return MediaPlayerCall(this); }
+
+  void publish_state();
+
+  void add_on_state_callback(std::function<void()> &&callback);
+
+  virtual bool is_muted() const { return false; }
+
+  virtual MediaPlayerTraits get_traits() = 0;
+
+ protected:
+  friend MediaPlayerCall;
+
+  virtual void control(const MediaPlayerCall &call) = 0;
+  uint32_t hash_base() override;
+
+  CallbackManager<void()> state_callback_{};
+};
+
+}  // namespace media_player
+}  // namespace esphome
diff --git a/esphome/core/application.h b/esphome/core/application.h
index cec6e7baa9..453b15822e 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -45,6 +45,9 @@
 #ifdef USE_LOCK
 #include "esphome/components/lock/lock.h"
 #endif
+#ifdef USE_MEDIA_PLAYER
+#include "esphome/components/media_player/media_player.h"
+#endif
 
 namespace esphome {
 
@@ -111,6 +114,10 @@ class Application {
   void register_lock(lock::Lock *a_lock) { this->locks_.push_back(a_lock); }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+  void register_media_player(media_player::MediaPlayer *media_player) { this->media_players_.push_back(media_player); }
+#endif
+
   /// Register the component in this Application instance.
   template<class C> C *register_component(C *c) {
     static_assert(std::is_base_of<Component, C>::value, "Only Component subclasses can be registered");
@@ -273,6 +280,15 @@ class Application {
     return nullptr;
   }
 #endif
+#ifdef USE_MEDIA_PLAYER
+  const std::vector<media_player::MediaPlayer *> &get_media_players() { return this->media_players_; }
+  media_player::MediaPlayer *get_media_player_by_key(uint32_t key, bool include_internal = false) {
+    for (auto *obj : this->media_players_)
+      if (obj->get_object_id_hash() == key && (include_internal || !obj->is_internal()))
+        return obj;
+    return nullptr;
+  }
+#endif
 
   Scheduler scheduler;
 
@@ -324,6 +340,9 @@ class Application {
 #ifdef USE_LOCK
   std::vector<lock::Lock *> locks_{};
 #endif
+#ifdef USE_MEDIA_PLAYER
+  std::vector<media_player::MediaPlayer *> media_players_{};
+#endif
 
   std::string name_;
   std::string compilation_time_;
diff --git a/esphome/core/component_iterator.cpp b/esphome/core/component_iterator.cpp
index 4781607a2d..16c56a90c5 100644
--- a/esphome/core/component_iterator.cpp
+++ b/esphome/core/component_iterator.cpp
@@ -231,6 +231,21 @@ void ComponentIterator::advance() {
         }
       }
       break;
+#endif
+#ifdef USE_MEDIA_PLAYER
+    case IteratorState::MEDIA_PLAYER:
+      if (this->at_ >= App.get_media_players().size()) {
+        advance_platform = true;
+      } else {
+        auto *media_player = App.get_media_players()[this->at_];
+        if (media_player->is_internal() && !this->include_internal_) {
+          success = true;
+          break;
+        } else {
+          success = this->on_media_player(media_player);
+        }
+      }
+      break;
 #endif
     case IteratorState::MAX:
       if (this->on_end()) {
@@ -254,4 +269,7 @@ bool ComponentIterator::on_service(api::UserServiceDescriptor *service) { return
 #ifdef USE_ESP32_CAMERA
 bool ComponentIterator::on_camera(esp32_camera::ESP32Camera *camera) { return true; }
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool ComponentIterator::on_media_player(media_player::MediaPlayer *media_player) { return true; }
+#endif
 }  // namespace esphome
diff --git a/esphome/core/component_iterator.h b/esphome/core/component_iterator.h
index bd95fe95e1..e8e048bd73 100644
--- a/esphome/core/component_iterator.h
+++ b/esphome/core/component_iterator.h
@@ -62,6 +62,9 @@ class ComponentIterator {
 #endif
 #ifdef USE_LOCK
   virtual bool on_lock(lock::Lock *a_lock) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual bool on_media_player(media_player::MediaPlayer *media_player);
 #endif
   virtual bool on_end();
 
@@ -110,6 +113,9 @@ class ComponentIterator {
 #endif
 #ifdef USE_LOCK
     LOCK,
+#endif
+#ifdef USE_MEDIA_PLAYER
+    MEDIA_PLAYER,
 #endif
     MAX,
   } state_{IteratorState::NONE};
diff --git a/esphome/core/controller.cpp b/esphome/core/controller.cpp
index 7d63a3d143..857ee6398f 100644
--- a/esphome/core/controller.cpp
+++ b/esphome/core/controller.cpp
@@ -73,6 +73,12 @@ void Controller::setup_controller(bool include_internal) {
       obj->add_on_state_callback([this, obj]() { this->on_lock_update(obj); });
   }
 #endif
+#ifdef USE_MEDIA_PLAYER
+  for (auto *obj : App.get_media_players()) {
+    if (include_internal || !obj->is_internal())
+      obj->add_on_state_callback([this, obj]() { this->on_media_player_update(obj); });
+  }
+#endif
 }
 
 }  // namespace esphome
diff --git a/esphome/core/controller.h b/esphome/core/controller.h
index 419624a2ae..0966504c43 100644
--- a/esphome/core/controller.h
+++ b/esphome/core/controller.h
@@ -37,6 +37,9 @@
 #ifdef USE_LOCK
 #include "esphome/components/lock/lock.h"
 #endif
+#ifdef USE_MEDIA_PLAYER
+#include "esphome/components/media_player/media_player.h"
+#endif
 
 namespace esphome {
 
@@ -76,6 +79,9 @@ class Controller {
 #ifdef USE_LOCK
   virtual void on_lock_update(lock::Lock *obj){};
 #endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_update(media_player::MediaPlayer *obj){};
+#endif
 };
 
 }  // namespace esphome
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index c854e2b987..5b1d567aa4 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -29,6 +29,7 @@
 #define USE_LOCK
 #define USE_LOGGER
 #define USE_MDNS
+#define USE_MEDIA_PLAYER
 #define USE_MQTT
 #define USE_NUMBER
 #define USE_OTA_PASSWORD
diff --git a/platformio.ini b/platformio.ini
index 82cf6eeb9a..fb33087a8a 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -120,10 +120,12 @@ lib_deps =
     HTTPClient                      ; http_request,nextion (Arduino built-in)
     ESPmDNS                         ; mdns (Arduino built-in)
     DNSServer                       ; captive_portal (Arduino built-in)
+    esphome/ESP32-audioI2S@2.1.0    ; i2s_audio
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_ESP32
     -DUSE_ESP32_FRAMEWORK_ARDUINO
+    -DAUDIO_NO_SD_FS                ; i2s_audio
 extra_scripts = post:esphome/components/esp32/post_build.py.script
 
 ; This are common settings for the ESP32 (all variants) using IDF.
diff --git a/tests/test4.yaml b/tests/test4.yaml
index 0e9f14e0d6..ce7a87411e 100644
--- a/tests/test4.yaml
+++ b/tests/test4.yaml
@@ -604,3 +604,12 @@ touchscreen:
       - logger.log:
           format: Touch at (%d, %d)
           args: ["touch.x", "touch.y"]
+
+media_player:
+  - platform: i2s_audio
+    name: ${friendly_name}
+    dac_type: external
+    i2s_lrclk_pin: GPIO26
+    i2s_dout_pin: GPIO25
+    i2s_bclk_pin: GPIO27
+    mute_pin: GPIO14