diff --git a/include/zephyr/net/lwm2m.h b/include/zephyr/net/lwm2m.h
index 51324f63153..3fca8bffae3 100644
--- a/include/zephyr/net/lwm2m.h
+++ b/include/zephyr/net/lwm2m.h
@@ -134,6 +134,22 @@ typedef void (*lwm2m_ctx_event_cb_t)(struct lwm2m_ctx *ctx,
 				     enum lwm2m_rd_client_event event);
 
 
+/**
+ * @brief Different traffic states of the LwM2M socket.
+ *
+ * This information can be used to give hints for the network interface
+ * that can decide what kind of power management should be used.
+ *
+ * These hints are given from CoAP layer messages, so usage of DTLS might affect the
+ * actual number of expected datagrams.
+ */
+enum lwm2m_socket_states {
+	LWM2M_SOCKET_STATE_ONGOING,	 /**< Ongoing traffic is expected. */
+	LWM2M_SOCKET_STATE_ONE_RESPONSE, /**< One response is expected for the next message. */
+	LWM2M_SOCKET_STATE_LAST,	 /**< Next message is the last one. */
+	LWM2M_SOCKET_STATE_NO_DATA,	 /**< No more data is expected. */
+};
+
 /**
  * @brief LwM2M context structure to maintain information for a single
  * LwM2M connection.
@@ -249,6 +265,14 @@ struct lwm2m_ctx {
 	 *  copied into the actual resource buffer.
 	 */
 	uint8_t validate_buf[CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE];
+
+	/**
+	 * Callback to indicate transmission states.
+	 * Client application may request LwM2M engine to indicate hints about
+	 * transmission states and use that information to control various power
+	 * saving modes.
+	 */
+	void (*set_socket_state)(int fd, enum lwm2m_socket_states state);
 };
 
 /**
diff --git a/samples/net/lwm2m_client/overlay-queue.conf b/samples/net/lwm2m_client/overlay-queue.conf
index 1adc9eda5ec..946c0fbab67 100644
--- a/samples/net/lwm2m_client/overlay-queue.conf
+++ b/samples/net/lwm2m_client/overlay-queue.conf
@@ -1,5 +1,7 @@
 CONFIG_LWM2M_QUEUE_MODE_ENABLED=y
 CONFIG_LWM2M_QUEUE_MODE_UPTIME=20
+CONFIG_LWM2M_RD_CLIENT_STOP_POLLING_AT_IDLE=y
+
 # Default lifetime is 1 day
 CONFIG_LWM2M_ENGINE_DEFAULT_LIFETIME=86400
 # Send update once an hour
diff --git a/samples/net/lwm2m_client/src/lwm2m-client.c b/samples/net/lwm2m_client/src/lwm2m-client.c
index c610f1ad8dd..2e9792e51ea 100644
--- a/samples/net/lwm2m_client/src/lwm2m-client.c
+++ b/samples/net/lwm2m_client/src/lwm2m-client.c
@@ -253,6 +253,25 @@ static void rd_client_event(struct lwm2m_ctx *client,
 	}
 }
 
+static void socket_state(int fd, enum lwm2m_socket_states state)
+{
+	(void) fd;
+	switch (state) {
+	case LWM2M_SOCKET_STATE_ONGOING:
+		LOG_DBG("LWM2M_SOCKET_STATE_ONGOING");
+		break;
+	case LWM2M_SOCKET_STATE_ONE_RESPONSE:
+		LOG_DBG("LWM2M_SOCKET_STATE_ONE_RESPONSE");
+		break;
+	case LWM2M_SOCKET_STATE_LAST:
+		LOG_DBG("LWM2M_SOCKET_STATE_LAST");
+		break;
+	case LWM2M_SOCKET_STATE_NO_DATA:
+		LOG_DBG("LWM2M_SOCKET_STATE_NO_DATA");
+		break;
+	}
+}
+
 static void observe_cb(enum lwm2m_observe_event event,
 		       struct lwm2m_obj_path *path, void *user_data)
 {
@@ -367,6 +386,7 @@ int main(void)
 #if defined(CONFIG_LWM2M_DTLS_SUPPORT)
 	client_ctx.tls_tag = CONFIG_LWM2M_APP_TLS_TAG;
 #endif
+	client_ctx.set_socket_state = socket_state;
 
 	/* client_ctx.sec_obj_inst is 0 as a starting point */
 	lwm2m_rd_client_start(&client_ctx, endpoint, flags, rd_client_event, observe_cb);
diff --git a/subsys/net/lib/lwm2m/lwm2m_engine.c b/subsys/net/lib/lwm2m/lwm2m_engine.c
index 85a428eeb5d..d5a289a111f 100644
--- a/subsys/net/lib/lwm2m/lwm2m_engine.c
+++ b/subsys/net/lib/lwm2m/lwm2m_engine.c
@@ -197,6 +197,11 @@ int lwm2m_socket_suspend(struct lwm2m_ctx *client_ctx)
 		lwm2m_close_socket(client_ctx);
 		/* store back the socket handle */
 		client_ctx->sock_fd = socket_temp_id;
+
+		if (client_ctx->set_socket_state) {
+			client_ctx->set_socket_state(client_ctx->sock_fd,
+						     LWM2M_SOCKET_STATE_NO_DATA);
+		}
 	}
 
 	return ret;
@@ -659,10 +664,10 @@ static int socket_recv_message(struct lwm2m_ctx *client_ctx)
 	return 0;
 }
 
-static int socket_send_message(struct lwm2m_ctx *client_ctx)
+static int socket_send_message(struct lwm2m_ctx *ctx)
 {
 	int rc;
-	sys_snode_t *msg_node = sys_slist_get(&client_ctx->pending_sends);
+	sys_snode_t *msg_node = sys_slist_get(&ctx->pending_sends);
 	struct lwm2m_message *msg;
 
 	if (!msg_node) {
@@ -679,6 +684,32 @@ static int socket_send_message(struct lwm2m_ctx *client_ctx)
 		coap_pending_cycle(msg->pending);
 	}
 
+	if (ctx->set_socket_state) {
+#if defined(CONFIG_LWM2M_QUEUE_MODE_ENABLED)
+		bool empty = sys_slist_is_empty(&ctx->pending_sends) &&
+			     sys_slist_is_empty(&ctx->queued_messages);
+#else
+		bool empty = sys_slist_is_empty(&ctx->pending_sends);
+#endif
+		if (coap_pendings_count(ctx->pendings, ARRAY_SIZE(ctx->pendings)) > 1) {
+			empty = false;
+		}
+
+		if (!empty) {
+			ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_ONGOING);
+		} else {
+			switch (msg->type) {
+			case COAP_TYPE_CON:
+				ctx->set_socket_state(ctx->sock_fd,
+						      LWM2M_SOCKET_STATE_ONE_RESPONSE);
+				break;
+			default:
+				ctx->set_socket_state(ctx->sock_fd, LWM2M_SOCKET_STATE_LAST);
+				break;
+			}
+		}
+	}
+
 	rc = zsock_send(msg->ctx->sock_fd, msg->cpkt.data, msg->cpkt.offset, 0);
 
 	if (rc < 0) {
diff --git a/tests/net/lib/lwm2m/lwm2m_engine/src/main.c b/tests/net/lib/lwm2m/lwm2m_engine/src/main.c
index ed26380eccd..5d80f5d1049 100644
--- a/tests/net/lib/lwm2m/lwm2m_engine/src/main.c
+++ b/tests/net/lib/lwm2m/lwm2m_engine/src/main.c
@@ -13,10 +13,11 @@
 #include "lwm2m_rd_client.h"
 
 #include "stubs.h"
-#if defined(CONFIG_NATIVE_POSIX_SLOWDOWN_TO_REAL_TIME)
+#if defined(CONFIG_NATIVE_SIM_SLOWDOWN_TO_REAL_TIME)
 #include "timer_model.h"
 #endif
 
+#define LOG_LEVEL	LOG_LEVEL_DBG
 LOG_MODULE_REGISTER(lwm2m_engine_test);
 
 DEFINE_FFF_GLOBALS;
@@ -67,7 +68,7 @@ static void test_service(struct k_work *work)
 
 static void setup(void *data)
 {
-#if defined(CONFIG_NATIVE_POSIX_SLOWDOWN_TO_REAL_TIME)
+#if defined(CONFIG_NATIVE_SIM_SLOWDOWN_TO_REAL_TIME)
 	/* It is enough that some slow-down is happening on sleeps, it does not have to be
 	 * real time
 	 */
@@ -467,3 +468,70 @@ ZTEST(lwm2m_engine, test_security)
 	zassert_equal(tls_credential_add_fake.arg1_history[2], TLS_CREDENTIAL_CA_CERTIFICATE);
 	zassert_equal(lwm2m_engine_stop(&ctx), 0);
 }
+
+static enum lwm2m_socket_states last_state;
+
+static void socket_state(int fd, enum lwm2m_socket_states state)
+{
+	(void) fd;
+	last_state = state;
+}
+
+ZTEST(lwm2m_engine, test_socket_state)
+{
+	int ret;
+	struct lwm2m_ctx ctx = {
+		.remote_addr.sa_family = AF_INET,
+		.sock_fd = -1,
+		.set_socket_state = socket_state,
+	};
+	struct lwm2m_message msg1 = {
+		.ctx = &ctx,
+		.type = COAP_TYPE_CON,
+	};
+	struct lwm2m_message msg2 = msg1;
+	struct lwm2m_message ack = {
+		.ctx = &ctx,
+		.type = COAP_TYPE_ACK,
+	};
+
+	sys_slist_init(&ctx.pending_sends);
+	ret = lwm2m_engine_start(&ctx);
+	zassert_equal(ret, 0);
+
+	/* One confimable in queue, should cause ONE_RESPONSE status */
+	coap_pendings_count_fake.return_val = 1;
+	sys_slist_append(&ctx.pending_sends, &msg1.node);
+	set_socket_events(ZSOCK_POLLOUT);
+	k_sleep(K_MSEC(100));
+	zassert_equal(last_state, LWM2M_SOCKET_STATE_ONE_RESPONSE);
+
+	/* More than one messages in queue, not empty, should cause ONGOING */
+	coap_pendings_count_fake.return_val = 2;
+	sys_slist_append(&ctx.pending_sends, &msg1.node);
+	sys_slist_append(&ctx.pending_sends, &msg2.node);
+	set_socket_events(ZSOCK_POLLOUT);
+	k_sleep(K_MSEC(100));
+	zassert_equal(last_state, LWM2M_SOCKET_STATE_ONGOING);
+
+	/* Last out, while waiting for ACK to both, should still cause ONGOING */
+	coap_pendings_count_fake.return_val = 2;
+	set_socket_events(ZSOCK_POLLOUT);
+	k_sleep(K_MSEC(100));
+	zassert_equal(last_state, LWM2M_SOCKET_STATE_ONGOING);
+
+	/* Only one Ack transmiting, nothing expected back -> LAST */
+	coap_pendings_count_fake.return_val = 0;
+	sys_slist_append(&ctx.pending_sends, &ack.node);
+	set_socket_events(ZSOCK_POLLOUT);
+	k_sleep(K_MSEC(100));
+	zassert_equal(last_state, LWM2M_SOCKET_STATE_LAST);
+
+	/* Socket suspended (as in QUEUE_RX_OFF), should cause NO_DATA */
+	ret = lwm2m_socket_suspend(&ctx);
+	zassert_equal(ret, 0);
+	zassert_equal(last_state, LWM2M_SOCKET_STATE_NO_DATA);
+
+	ret = lwm2m_engine_stop(&ctx);
+	zassert_equal(ret, 0);
+}
diff --git a/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.c b/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.c
index 5db155f1e29..0958d75a54a 100644
--- a/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.c
+++ b/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.c
@@ -19,6 +19,7 @@ DEFINE_FAKE_VALUE_FUNC(int, lwm2m_send_message_async, struct lwm2m_message *);
 DEFINE_FAKE_VOID_FUNC(lwm2m_registry_lock);
 DEFINE_FAKE_VOID_FUNC(lwm2m_registry_unlock);
 DEFINE_FAKE_VALUE_FUNC(bool, coap_pending_cycle, struct coap_pending *);
+DEFINE_FAKE_VALUE_FUNC(size_t, coap_pendings_count, struct coap_pending *, size_t);
 DEFINE_FAKE_VALUE_FUNC(int, generate_notify_message, struct lwm2m_ctx *, struct observe_node *,
 		       void *);
 DEFINE_FAKE_VALUE_FUNC(int64_t, engine_observe_shedule_next_event, struct observe_node *, uint16_t,
@@ -41,6 +42,7 @@ DEFINE_FAKE_VALUE_FUNC(int, lwm2m_delete_obj_inst, uint16_t, uint16_t);
 DEFINE_FAKE_VOID_FUNC(lwm2m_clear_block_contexts);
 DEFINE_FAKE_VALUE_FUNC(int, lwm2m_security_mode, struct lwm2m_ctx *);
 DEFINE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void *, socklen_t);
+DEFINE_FAKE_VOID_FUNC(engine_update_tx_time);
 
 static sys_slist_t obs_obj_path_list = SYS_SLIST_STATIC_INIT(&obs_obj_path_list);
 sys_slist_t *lwm2m_obs_obj_path_list(void)
diff --git a/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.h b/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.h
index 7b8ca481f85..67c4cde883d 100644
--- a/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.h
+++ b/tests/net/lib/lwm2m/lwm2m_engine/src/stubs.h
@@ -28,6 +28,7 @@ DECLARE_FAKE_VALUE_FUNC(int, lwm2m_rd_client_resume);
 DECLARE_FAKE_VALUE_FUNC(struct lwm2m_message *, find_msg, struct coap_pending *,
 			struct coap_reply *);
 DECLARE_FAKE_VOID_FUNC(coap_pending_clear, struct coap_pending *);
+DECLARE_FAKE_VALUE_FUNC(size_t, coap_pendings_count, struct coap_pending *, size_t);
 DECLARE_FAKE_VOID_FUNC(lwm2m_reset_message, struct lwm2m_message *, bool);
 DECLARE_FAKE_VALUE_FUNC(int, lwm2m_send_message_async, struct lwm2m_message *);
 DECLARE_FAKE_VOID_FUNC(lwm2m_registry_lock);
@@ -56,6 +57,7 @@ DECLARE_FAKE_VOID_FUNC(lwm2m_clear_block_contexts);
 DECLARE_FAKE_VALUE_FUNC(int, z_impl_zsock_connect, int, const struct sockaddr *, socklen_t);
 DECLARE_FAKE_VALUE_FUNC(int, lwm2m_security_mode, struct lwm2m_ctx *);
 DECLARE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void *, socklen_t);
+DECLARE_FAKE_VOID_FUNC(engine_update_tx_time);
 
 #define DO_FOREACH_FAKE(FUNC)                                                                      \
 	do {                                                                                       \
@@ -63,6 +65,7 @@ DECLARE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void
 		FUNC(lwm2m_rd_client_resume)                                                       \
 		FUNC(find_msg)                                                                     \
 		FUNC(coap_pending_clear)                                                           \
+		FUNC(coap_pendings_count)                                                          \
 		FUNC(lwm2m_reset_message)                                                          \
 		FUNC(lwm2m_send_message_async)                                                     \
 		FUNC(lwm2m_registry_lock)                                                          \
@@ -85,6 +88,7 @@ DECLARE_FAKE_VALUE_FUNC(int, z_impl_zsock_setsockopt, int, int, int, const void
 		FUNC(z_impl_zsock_connect)                                                         \
 		FUNC(lwm2m_security_mode)                                                          \
 		FUNC(z_impl_zsock_setsockopt)                                                      \
+		FUNC(engine_update_tx_time)                                                        \
 	} while (0)
 
 #endif /* STUBS_H */