diff --git a/benchmarks/benches/room_bench.rs b/benchmarks/benches/room_bench.rs
index cdd92b557..b1c25adb1 100644
--- a/benchmarks/benches/room_bench.rs
+++ b/benchmarks/benches/room_bench.rs
@@ -18,7 +18,6 @@ use ruma::{
     serde::Raw,
     user_id,
 };
-use serde_json::json;
 use tokio::runtime::Builder;
 use wiremock::{Request, ResponseTemplate};
 
@@ -114,21 +113,8 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
     let pinned_event_ids: Vec<OwnedEventId> = (0..PINNED_EVENTS_COUNT)
         .map(|i| EventId::parse(format!("${i}")).expect("Invalid event id"))
         .collect();
-    joined_room_builder = joined_room_builder.add_state_event(StateTestEvent::Custom(json!(
-        {
-            "content": {
-                "pinned": pinned_event_ids
-            },
-            "event_id": "$15139375513VdeRF:localhost",
-            "origin_server_ts": 151393755,
-            "sender": "@example:localhost",
-            "state_key": "",
-            "type": "m.room.pinned_events",
-            "unsigned": {
-                "age": 703422
-            }
-        }
-    )));
+    joined_room_builder =
+        joined_room_builder.add_state_bulk(vec![f.room_pinned_events(pinned_event_ids).into()]);
 
     let (server, client, room) = runtime.block_on(async move {
         let server = MatrixMockServer::new().await;
diff --git a/crates/matrix-sdk-base/src/room/room_info.rs b/crates/matrix-sdk-base/src/room/room_info.rs
index 6954ec195..f58e2f32f 100644
--- a/crates/matrix-sdk-base/src/room/room_info.rs
+++ b/crates/matrix-sdk-base/src/room/room_info.rs
@@ -1350,13 +1350,10 @@ mod tests {
     use std::sync::Arc;
 
     use assert_matches::assert_matches;
-    use matrix_sdk_test::{
-        async_test,
-        test_json::{TAG, sync_events::PINNED_EVENTS},
-    };
+    use matrix_sdk_test::{async_test, event_factory::EventFactory, test_json::TAG};
     use ruma::{
         assign, events::room::pinned_events::RoomPinnedEventsEventContent, owned_event_id,
-        owned_mxc_uri, owned_user_id, room_id, serde::Raw,
+        owned_mxc_uri, owned_user_id, room_id, serde::Raw, user_id,
     };
     use serde_json::json;
     use similar_asserts::assert_eq;
@@ -1544,7 +1541,10 @@ mod tests {
         let tag_event = raw_tag_event.deserialize().unwrap();
         changes.add_room_account_data(&room_info.room_id, tag_event, raw_tag_event);
 
-        let raw_pinned_events_event = Raw::new(&*PINNED_EVENTS).unwrap().cast_unchecked();
+        let f = EventFactory::new().room(&room_info.room_id).sender(user_id!("@example:localhost"));
+        let raw_pinned_events_event: Raw<_> = f
+            .room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")])
+            .into_raw_sync_state();
         let pinned_events_event = raw_pinned_events_event.deserialize().unwrap();
         changes.add_state_event(&room_info.room_id, pinned_events_event, raw_pinned_events_event);
 
diff --git a/crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs b/crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs
index 8ee4adbb0..c77fa0701 100644
--- a/crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs
+++ b/crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs
@@ -29,14 +29,12 @@ use ruma::{
                 EncryptedEventScheme, MegolmV1AesSha2ContentInit, RoomEncryptedEventContent,
             },
             message::RoomMessageEventContentWithoutRelation,
-            pinned_events::RoomPinnedEventsEventContent,
         },
     },
     owned_device_id, owned_room_id, owned_user_id, room_id,
     serde::Raw,
     user_id,
 };
-use serde_json::json;
 use stream_assert::assert_pending;
 use tokio::time::sleep;
 use wiremock::{
@@ -866,7 +864,8 @@ async fn test_ensure_max_concurrency_is_observed() {
     let (client, server) = logged_in_client_with_server().await;
     let room_id = owned_room_id!("!a_room:example.org");
 
-    let pinned_event_ids: Vec<String> = (0..100).map(|idx| format!("${idx}")).collect();
+    let pinned_event_ids: Vec<OwnedEventId> =
+        (0..100).map(|idx| EventId::parse(format!("${idx}")).unwrap()).collect();
 
     let max_concurrent_requests = 10;
 
@@ -874,25 +873,12 @@ async fn test_ensure_max_concurrency_is_observed() {
     client.event_cache().config_mut().await.max_pinned_events_concurrent_requests =
         max_concurrent_requests;
 
+    let f = EventFactory::new().room(&room_id).sender(user_id!("@example:localhost"));
     let joined_room_builder = JoinedRoomBuilder::new(&room_id)
         // Set up encryption
         .add_state_event(StateTestEvent::Encryption)
         // Add 100 pinned events
-        .add_state_event(StateTestEvent::Custom(json!(
-            {
-                "content": {
-                    "pinned": pinned_event_ids
-                },
-                "event_id": "$15139375513VdeRF:localhost",
-                "origin_server_ts": 151393755,
-                "sender": "@example:localhost",
-                "state_key": "",
-                "type": "m.room.pinned_events",
-                "unsigned": {
-                    "age": 703422
-                }
-            }
-        )));
+        .add_state_bulk(vec![f.room_pinned_events(pinned_event_ids).into()]);
 
     let pinned_event =
         EventFactory::new().room(&room_id).sender(*BOB).text_msg("A message").into_raw_timeline();
@@ -1000,9 +986,8 @@ impl PinnedEventsSync {
         if let Some(pinned_event_ids) = self.pinned_event_ids {
             let pinned_events_event = EventFactory::new()
                 .room(&self.room_id)
-                .event(RoomPinnedEventsEventContent::new(pinned_event_ids))
                 .sender(user_id!("@example:localhost"))
-                .state_key("")
+                .room_pinned_events(pinned_event_ids)
                 .into();
 
             joined_room_builder = joined_room_builder.add_state_bulk(vec![pinned_events_event]);
diff --git a/crates/matrix-sdk/tests/integration/client.rs b/crates/matrix-sdk/tests/integration/client.rs
index 9ad1eddf1..5d797f36e 100644
--- a/crates/matrix-sdk/tests/integration/client.rs
+++ b/crates/matrix-sdk/tests/integration/client.rs
@@ -27,7 +27,6 @@ use matrix_sdk_test::{
             MIXED_INVITED_ROOM_ID, MIXED_JOINED_ROOM_ID, MIXED_KNOCKED_ROOM_ID, MIXED_LEFT_ROOM_ID,
             MIXED_SYNC,
         },
-        sync_events::PINNED_EVENTS,
     },
 };
 use ruma::{
@@ -1371,7 +1370,10 @@ async fn test_restore_room() {
     let tag_event = raw_tag_event.deserialize().unwrap();
     changes.add_room_account_data(room_id, tag_event, raw_tag_event);
 
-    let raw_pinned_events_event = Raw::new(&*PINNED_EVENTS).unwrap().cast_unchecked();
+    let f = EventFactory::new().room(room_id).sender(user_id!("@example:localhost"));
+    let raw_pinned_events_event: Raw<_> = f
+        .room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")])
+        .into_raw_sync_state();
     let pinned_events_event = raw_pinned_events_event.deserialize().unwrap();
     changes.add_state_event(room_id, pinned_events_event, raw_pinned_events_event);
 
diff --git a/crates/matrix-sdk/tests/integration/room/pinned_events.rs b/crates/matrix-sdk/tests/integration/room/pinned_events.rs
index 1f84df56a..6f3b8ef87 100644
--- a/crates/matrix-sdk/tests/integration/room/pinned_events.rs
+++ b/crates/matrix-sdk/tests/integration/room/pinned_events.rs
@@ -9,7 +9,7 @@ use matrix_sdk::{
     timeout::timeout,
 };
 use matrix_sdk_base::event_cache::store::MemoryStore;
-use matrix_sdk_test::{JoinedRoomBuilder, StateTestEvent, async_test, event_factory::EventFactory};
+use matrix_sdk_test::{JoinedRoomBuilder, async_test, event_factory::EventFactory};
 use ruma::{EventId, event_id, owned_event_id, room_id, user_id};
 use serde_json::json;
 use tokio::time::Duration;
@@ -50,14 +50,15 @@ impl PinningTestSetup<'_> {
     }
 
     async fn mock_sync(&mut self, include_pinned_state_event: bool) {
-        let f = EventFactory::new().sender(user_id!("@a:b.c"));
+        let f = EventFactory::new().room(self.room_id).sender(user_id!("@a:b.c"));
 
         let mut joined_room_builder = JoinedRoomBuilder::new(self.room_id)
             .add_timeline_event(f.text_msg("A").event_id(self.event_id).into_raw_sync());
 
         if include_pinned_state_event {
-            joined_room_builder =
-                joined_room_builder.add_state_event(StateTestEvent::RoomPinnedEvents);
+            let pinned_events =
+                f.room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")]);
+            joined_room_builder = joined_room_builder.add_state_bulk(vec![pinned_events.into()]);
         }
 
         self.server.sync_room(&self.client, joined_room_builder).await;
@@ -177,21 +178,12 @@ async fn test_pinned_events_are_reloaded_from_storage() {
         // This is important: the pinned events list must include our event ID,
         // otherwise the initial reload from network will clear the storage-loaded
         // events.
-        let pinned_events_state = StateTestEvent::Custom(json!({
-            "content": {
-                "pinned": [pinned_event_id]
-            },
-            "event_id": "$pinned_events_state",
-            "origin_server_ts": 151393755,
-            "sender": "@example:localhost",
-            "state_key": "",
-            "type": "m.room.pinned_events",
-        }));
+        let pinned_events_state = f.room_pinned_events(vec![pinned_event_id.to_owned()]);
 
         let room = server
             .sync_room(
                 &client,
-                JoinedRoomBuilder::new(room_id).add_state_event(pinned_events_state),
+                JoinedRoomBuilder::new(room_id).add_state_bulk(vec![pinned_events_state.into()]),
             )
             .await;
 
@@ -314,19 +306,13 @@ async fn test_pinned_events_dont_include_thread_responses() {
     // This is important: the pinned events list must include our event ID,
     // otherwise the initial reload from network will clear the storage-loaded
     // events.
-    let pinned_events_state = StateTestEvent::Custom(json!({
-        "content": {
-            "pinned": [pinned_event_id]
-        },
-        "event_id": "$pinned_events_state",
-        "origin_server_ts": 151393755,
-        "sender": "@example:localhost",
-        "state_key": "",
-        "type": "m.room.pinned_events",
-    }));
+    let pinned_events_state = f.room_pinned_events(vec![pinned_event_id.to_owned()]);
 
     let room = server
-        .sync_room(&client, JoinedRoomBuilder::new(room_id).add_state_event(pinned_events_state))
+        .sync_room(
+            &client,
+            JoinedRoomBuilder::new(room_id).add_state_bulk(vec![pinned_events_state.into()]),
+        )
         .await;
 
     // Get the room event cache and subscribe to pinned events.
diff --git a/testing/matrix-sdk-test/src/event_factory.rs b/testing/matrix-sdk-test/src/event_factory.rs
index e6bfe4c2f..0ddc9f21d 100644
--- a/testing/matrix-sdk-test/src/event_factory.rs
+++ b/testing/matrix-sdk-test/src/event_factory.rs
@@ -71,6 +71,7 @@ use ruma::{
                 RoomMessageEventContentWithoutRelation,
             },
             name::RoomNameEventContent,
+            pinned_events::RoomPinnedEventsEventContent,
             power_levels::RoomPowerLevelsEventContent,
             redaction::RoomRedactionEventContent,
             server_acl::RoomServerAclEventContent,
@@ -975,6 +976,14 @@ impl EventFactory {
         event
     }
 
+    /// Create a state event for the room's pinned events.
+    pub fn room_pinned_events(
+        &self,
+        pinned: Vec<OwnedEventId>,
+    ) -> EventBuilder<RoomPinnedEventsEventContent> {
+        self.event(RoomPinnedEventsEventContent::new(pinned)).state_key("")
+    }
+
     /// Create a new `m.member_hints` event with the given service members.
     ///
     /// ```
diff --git a/testing/matrix-sdk-test/src/sync_builder/test_event.rs b/testing/matrix-sdk-test/src/sync_builder/test_event.rs
index 7bb508a88..476a2e176 100644
--- a/testing/matrix-sdk-test/src/sync_builder/test_event.rs
+++ b/testing/matrix-sdk-test/src/sync_builder/test_event.rs
@@ -28,7 +28,6 @@ pub enum StateTestEvent {
     RedactedState,
     RoomAvatar,
     RoomName,
-    RoomPinnedEvents,
     RoomTopic,
     Custom(JsonValue),
 }
@@ -62,7 +61,6 @@ impl From<StateTestEvent> for JsonValue {
             StateTestEvent::RedactedState => test_json::sync_events::REDACTED_STATE.to_owned(),
             StateTestEvent::RoomAvatar => test_json::sync_events::ROOM_AVATAR.to_owned(),
             StateTestEvent::RoomName => test_json::sync_events::NAME.to_owned(),
-            StateTestEvent::RoomPinnedEvents => test_json::sync_events::PINNED_EVENTS.to_owned(),
             StateTestEvent::RoomTopic => test_json::sync_events::TOPIC.to_owned(),
             StateTestEvent::Custom(json) => json,
         }
diff --git a/testing/matrix-sdk-test/src/test_json/sync_events.rs b/testing/matrix-sdk-test/src/test_json/sync_events.rs
index 54a8a5597..4330299d3 100644
--- a/testing/matrix-sdk-test/src/test_json/sync_events.rs
+++ b/testing/matrix-sdk-test/src/test_json/sync_events.rs
@@ -323,22 +323,6 @@ pub static NAME_STRIPPED: Lazy<JsonValue> = Lazy::new(|| {
     })
 });
 
-pub static PINNED_EVENTS: Lazy<JsonValue> = Lazy::new(|| {
-    json!({
-        "content": {
-            "pinned": [ "$a", "$b" ]
-        },
-        "event_id": "$15139375513VdeRF:localhost",
-        "origin_server_ts": 151393755,
-        "sender": "@example:localhost",
-        "state_key": "",
-        "type": "m.room.pinned_events",
-        "unsigned": {
-            "age": 703422
-        }
-    })
-});
-
 pub static POWER_LEVELS: Lazy<JsonValue> = Lazy::new(|| {
     json!({
         "content": {