diff --git a/src/input_capture.rs b/src/input_capture.rs
index 673cd21..816e2ca 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -2,7 +2,7 @@
 //!
 //! These are unified into a single [`TimestampedInputs`](crate::timestamped_input::TimestampedInputs) resource, which can be played back.
 
-use bevy::app::{App, AppExit, Last, Plugin};
+use bevy::app::{App, AppExit, First, Last, Plugin};
 use bevy::core::{update_frame_count, FrameCount};
 use bevy::ecs::prelude::*;
 use bevy::input::gamepad::GamepadEvent;
@@ -27,22 +27,62 @@ pub struct InputCapturePlugin;
 
 impl Plugin for InputCapturePlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<TimestampedInputs>()
-            .init_resource::<InputModesCaptured>()
-            .init_resource::<PlaybackFilePath>()
+        app.add_event::<BeginInputCapture>()
+            .add_event::<EndInputCapture>()
+            .add_systems(First, initiate_input_capture)
             .add_systems(
                 Last,
                 (
                     // Capture any mocked input as well
                     capture_input,
-                    serialize_captured_input_on_exit,
+                    (
+                        serialize_captured_input_on_final_capture_frame
+                            .run_if(resource_exists::<FinalCaptureFrame>),
+                        serialize_captured_input_on_end_capture_event,
+                        serialize_captured_input_on_exit,
+                    )
+                        .run_if(resource_exists::<PlaybackFilePath>),
                 )
+                    .run_if(resource_exists::<InputModesCaptured>)
                     .chain()
                     .before(update_frame_count),
             );
     }
 }
 
+/// An Event that users can send to initiate input capture.
+///
+/// Data is serialized to the provided `filepath` when either an [`EndInputCapture`] or an [`AppExit`] event is detected.
+#[derive(Debug, Default, Event)]
+pub struct BeginInputCapture {
+    /// The input mechanisms that will be captured, see [`InputModesCaptured`].
+    pub input_modes_captured: InputModesCaptured,
+    /// The filepath at which to serialize captured input data.
+    pub filepath: Option<String>,
+    /// The number of frames for which inputs should be captured.
+    /// If None, inputs will be captured until an [`EndInputCapture`] or [`AppExit`] event is detected.
+    pub frames_to_capture: Option<FrameCount>,
+    /// A `Window` entity which acts as a filter for which inputs will be captured.
+    /// This data will not be serialized, so that a target window can be selected on playback.
+    pub window_to_capture: Option<Entity>,
+}
+
+/// An Event that users can send to end input capture and serialize data to disk.
+#[derive(Debug, Event)]
+pub struct EndInputCapture;
+
+/// The final [`FrameCount`] at which inputs will stop being captured.
+///
+/// If this Resource is attached, [`TimestampedInputs`] will be serialized and input capture will stop once `FrameCount` reaches this value.
+#[derive(Debug, Resource)]
+pub struct FinalCaptureFrame(FrameCount);
+
+/// The `Window` entity for which inputs will be captured.
+///
+/// If this Resource is attached, only input events on the window corresponding to this entity will be captured.
+#[derive(Debug, Resource)]
+pub struct InputCaptureWindow(Entity);
+
 /// The input mechanisms captured via the [`InputCapturePlugin`], configured as a resource.
 ///
 /// By default, all supported input modes will be captured.
@@ -86,6 +126,32 @@ impl Default for InputModesCaptured {
     }
 }
 
+/// Initiates input capture when a [`BeginInputCapture`] is detected.
+pub fn initiate_input_capture(
+    mut commands: Commands,
+    mut begin_capture_events: EventReader<BeginInputCapture>,
+    frame_count: Res<FrameCount>,
+) {
+    if let Some(event) = begin_capture_events.read().next() {
+        commands.init_resource::<TimestampedInputs>();
+        commands.insert_resource(event.input_modes_captured.clone());
+        if let Some(path) = &event.filepath {
+            commands.insert_resource(PlaybackFilePath::new(path));
+        } else {
+            commands.init_resource::<PlaybackFilePath>();
+        }
+        if let Some(final_frame) = event.frames_to_capture {
+            commands.insert_resource(FinalCaptureFrame(FrameCount(
+                frame_count.0.wrapping_add(final_frame.0),
+            )));
+        }
+        if let Some(window_entity) = &event.window_to_capture {
+            commands.insert_resource(InputCaptureWindow(*window_entity));
+        }
+    }
+    begin_capture_events.clear();
+}
+
 /// Captures input from the [`bevy::window`] and [`bevy::input`] event streams.
 ///
 /// The input modes can be controlled via the [`InputModesCaptured`] resource.
@@ -98,6 +164,7 @@ pub fn capture_input(
     mut gamepad_events: EventReader<GamepadEvent>,
     mut app_exit_events: EventReader<AppExit>,
     mut timestamped_input: ResMut<TimestampedInputs>,
+    window_to_capture: Option<Res<InputCaptureWindow>>,
     input_modes_captured: Res<InputModesCaptured>,
     frame_count: Res<FrameCount>,
     time: Res<Time>,
@@ -113,13 +180,29 @@ pub fn capture_input(
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            mouse_button_events.read().cloned(),
+            mouse_button_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
 
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            mouse_wheel_events.read().cloned(),
+            mouse_wheel_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
     } else {
         mouse_button_events.clear();
@@ -130,14 +213,34 @@ pub fn capture_input(
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            cursor_moved_events.read().cloned(),
+            cursor_moved_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
     } else {
         cursor_moved_events.clear();
     }
 
     if input_modes_captured.keyboard {
-        timestamped_input.send_multiple(frame, time_since_startup, keyboard_events.read().cloned());
+        timestamped_input.send_multiple(
+            frame,
+            time_since_startup,
+            keyboard_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
+        );
     } else {
         keyboard_events.clear()
     }
@@ -151,9 +254,8 @@ pub fn capture_input(
     timestamped_input.send_multiple(frame, time_since_startup, app_exit_events.read().cloned())
 }
 
-/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource.
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once [`AppExit`] is sent.
 ///
-/// This data is only serialized once when [`AppExit`] is sent.
 /// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
 pub fn serialize_captured_input_on_exit(
     app_exit_events: EventReader<AppExit>,
@@ -165,6 +267,46 @@ pub fn serialize_captured_input_on_exit(
     }
 }
 
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once the provided number of frames have elapsed.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn serialize_captured_input_on_final_capture_frame(
+    mut commands: Commands,
+    frame_count: Res<FrameCount>,
+    final_frame: Res<FinalCaptureFrame>,
+    playback_file: Res<PlaybackFilePath>,
+    captured_inputs: Res<TimestampedInputs>,
+) {
+    if *frame_count == final_frame.0 {
+        serialize_timestamped_inputs(&captured_inputs, &playback_file);
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<InputModesCaptured>();
+        commands.remove_resource::<FinalCaptureFrame>();
+        commands.remove_resource::<InputCaptureWindow>();
+    }
+}
+
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn serialize_captured_input_on_end_capture_event(
+    mut commands: Commands,
+    mut end_capture_events: EventReader<EndInputCapture>,
+    playback_file: Res<PlaybackFilePath>,
+    captured_inputs: Res<TimestampedInputs>,
+) {
+    if !end_capture_events.is_empty() {
+        serialize_timestamped_inputs(&captured_inputs, &playback_file);
+        end_capture_events.clear();
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<InputModesCaptured>();
+        commands.remove_resource::<FinalCaptureFrame>();
+        commands.remove_resource::<InputCaptureWindow>();
+    }
+}
+
 /// Writes the `timestamped_inputs` to the provided `path` (which should store [`Some(PathBuf)`]).
 pub fn serialize_timestamped_inputs(
     timestamped_inputs: &TimestampedInputs,
diff --git a/src/input_playback.rs b/src/input_playback.rs
index 6f646d5..158e10e 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -2,7 +2,7 @@
 //!
 //! These are played back by emulating assorted Bevy input events.
 
-use bevy::app::{App, AppExit, First, Plugin, Startup};
+use bevy::app::{App, AppExit, First, Plugin};
 use bevy::core::FrameCount;
 use bevy::ecs::{prelude::*, system::SystemParam};
 use bevy::input::gamepad::GamepadEvent;
@@ -30,18 +30,131 @@ pub struct InputPlaybackPlugin;
 
 impl Plugin for InputPlaybackPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<TimestampedInputs>()
-            .init_resource::<PlaybackProgress>()
-            .init_resource::<PlaybackStrategy>()
-            .init_resource::<PlaybackFilePath>()
-            .add_systems(Startup, deserialize_timestamped_inputs)
+        app.add_event::<BeginInputPlayback>()
+            .add_event::<EndInputPlayback>()
             .add_systems(
                 First,
-                playback_timestamped_input.after(bevy::ecs::event::EventUpdates),
+                (handle_end_playback_event, initiate_input_playback)
+                    .chain()
+                    .after(bevy::ecs::event::EventUpdates),
+            )
+            .add_systems(
+                First,
+                playback_timestamped_input
+                    .run_if(
+                        resource_exists::<PlaybackProgress>
+                            .and_then(resource_exists::<TimestampedInputs>),
+                    )
+                    .after(initiate_input_playback),
             );
     }
 }
 
+/// An Event that users can send to initiate input capture.
+///
+/// Data is serialized to the provided `filepath` when either an [`EndCaptureEvent`] or an [`AppExit`] event is detected.
+#[derive(Debug, Default, Event)]
+pub struct BeginInputPlayback {
+    /// The source from which to read input data. Do not provide a `source` if the expected `TimestampedInputs` should already be present in `World`.
+    pub source: Option<InputPlaybackSource>,
+    /// Controls the approach used for playing back recorded inputs.
+    ///
+    /// See [`PlaybackStrategy`] for more information.
+    pub playback_strategy: PlaybackStrategy,
+    /// A entity corresponding to the [`bevy::window::Window`] which will receive input events.
+    /// If unspecified, input events will target the serialized window entity, which may be fragile.
+    pub playback_window: Option<Entity>,
+}
+
+/// The source of input data for playback.
+///
+/// Typically users should expect to provide a
+
+#[derive(Debug)]
+pub enum InputPlaybackSource {
+    /// Reads from a file and deserializes the content into a `TimestampedInputs`.
+    File(PlaybackFilePath),
+    /// Uses the provided `TimestampedInputs` parameter as the source of input data.
+    TimestampedInputs(TimestampedInputs),
+}
+
+impl InputPlaybackSource {
+    /// Reads source data from a file using the provided filepath.
+    pub fn from_file(filepath: impl AsRef<String>) -> Self {
+        InputPlaybackSource::File(PlaybackFilePath::new(filepath.as_ref()))
+    }
+
+    /// Defines source data using raw data.
+    pub fn from_inputs(inputs: TimestampedInputs) -> Self {
+        InputPlaybackSource::TimestampedInputs(inputs)
+    }
+}
+
+impl Default for InputPlaybackSource {
+    fn default() -> Self {
+        Self::TimestampedInputs(TimestampedInputs::default())
+    }
+}
+
+/// Initiates input playback when a [`BeginInputPlayback`] is detected.
+pub fn initiate_input_playback(
+    mut commands: Commands,
+    mut begin_capture_events: EventReader<BeginInputPlayback>,
+) {
+    let Some(event) = begin_capture_events.read().next() else {
+        return;
+    };
+
+    commands.init_resource::<PlaybackProgress>();
+    commands.insert_resource(event.playback_strategy);
+
+    if let Some(source) = event.source.as_ref() {
+        let timestamped_inputs = match source {
+            InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
+            InputPlaybackSource::File(playback_path) => {
+                commands.insert_resource(playback_path.clone());
+                deserialize_timestamped_inputs(playback_path)
+                    .unwrap()
+                    .unwrap()
+            }
+        };
+        commands.insert_resource(timestamped_inputs);
+    }
+
+    if let Some(playback_window) = event.playback_window {
+        commands.insert_resource(PlaybackWindow(playback_window));
+    }
+
+    begin_capture_events.clear();
+}
+
+/// An Event that users can send to end input playback prematurely.
+#[derive(Debug, Event)]
+pub struct EndInputPlayback;
+
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn handle_end_playback_event(
+    mut commands: Commands,
+    mut end_capture_events: EventReader<EndInputPlayback>,
+) {
+    if !end_capture_events.is_empty() {
+        end_capture_events.clear();
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<PlaybackProgress>();
+        commands.remove_resource::<PlaybackStrategy>();
+        commands.remove_resource::<PlaybackWindow>();
+    }
+}
+
+/// The `Window` entity for which inputs will be captured.
+///
+/// If this Resource is attached, input events will be forwarded to this window entity rather than the serialized window entity.
+#[derive(Debug, Resource)]
+pub struct PlaybackWindow(pub Entity);
+
 /// Controls the approach used for playing back recorded inputs
 ///
 /// [`PlaybackStrategy::Time`] is the default strategy.
@@ -216,12 +329,40 @@ fn send_playback_events(
 
 /// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
 pub fn deserialize_timestamped_inputs(
-    mut timestamped_inputs: ResMut<TimestampedInputs>,
-    playback_path: Res<PlaybackFilePath>,
-) {
-    if let Some(file_path) = playback_path.path() {
-        let file = File::open(file_path).unwrap();
-        *timestamped_inputs = from_reader(file).unwrap();
+    playback_path: &PlaybackFilePath,
+) -> Option<Result<TimestampedInputs, TimestampedInputsError>> {
+    playback_path.path().as_ref().map(|file_path| {
+        let file = File::open(file_path).map_err(TimestampedInputsError::Fs)?;
+        from_reader(file).map_err(TimestampedInputsError::Ron)
+    })
+}
+
+/// An error type that wraps the possible error variants when deserializing `TimestampedInputs` from a file.
+#[derive(Debug)]
+pub enum TimestampedInputsError {
+    /// The error case where the filesystem failed to open the desired file path.
+    Fs(std::io::Error),
+    /// The error case where the content at the provided filepath did not have valid RON content.
+    Ron(ron::de::SpannedError),
+}
+
+impl std::fmt::Display for TimestampedInputsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            TimestampedInputsError::Fs(_error) => write!(f, "could not find playback file "),
+            TimestampedInputsError::Ron(_error) => {
+                write!(f, "the provided file did not have valid RON-formatted data")
+            }
+        }
+    }
+}
+
+impl std::error::Error for TimestampedInputsError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            TimestampedInputsError::Fs(ref error) => Some(error),
+            TimestampedInputsError::Ron(ref error) => Some(error),
+        }
     }
 }
 
diff --git a/tests/input_capture.rs b/tests/input_capture.rs
index 415f30b..b897934 100644
--- a/tests/input_capture.rs
+++ b/tests/input_capture.rs
@@ -5,8 +5,9 @@ use bevy::input::mouse::MouseButtonInput;
 use bevy::input::ButtonState;
 use bevy::input::InputPlugin;
 use bevy::prelude::*;
-
 use bevy::window::WindowPlugin;
+
+use leafwing_input_playback::input_capture::BeginInputCapture;
 use leafwing_input_playback::input_capture::{InputCapturePlugin, InputModesCaptured};
 use leafwing_input_playback::timestamped_input::{
     InputEvent, TimestampedInputEvent, TimestampedInputs,
@@ -41,7 +42,7 @@ fn capture_app() -> App {
         InputPlugin,
         InputCapturePlugin,
     ));
-
+    app.world_mut().send_event(BeginInputCapture::default());
     app
 }
 
diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index 77d3c51..564ed08 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -13,6 +13,7 @@ use bevy::window::WindowPlugin;
 
 use leafwing_input_playback::input_capture::InputCapturePlugin;
 use leafwing_input_playback::input_capture::InputModesCaptured;
+use leafwing_input_playback::input_playback::BeginInputPlayback;
 use leafwing_input_playback::input_playback::InputPlaybackPlugin;
 use leafwing_input_playback::input_playback::PlaybackStrategy;
 use leafwing_input_playback::timestamped_input::TimestampedInputs;
@@ -44,7 +45,10 @@ fn playback_app(strategy: PlaybackStrategy) -> App {
     let mut registry = app.world_mut().resource_mut::<EventRegistry>();
     registry.should_update = ShouldUpdateEvents::Always;
 
-    *app.world_mut().resource_mut::<PlaybackStrategy>() = strategy;
+    app.world_mut().send_event(BeginInputPlayback {
+        playback_strategy: strategy,
+        ..Default::default()
+    });
 
     app
 }
@@ -74,7 +78,7 @@ fn minimal_playback() {
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    *app.world_mut().resource_mut::<TimestampedInputs>() = simple_timestamped_input();
+    app.insert_resource(simple_timestamped_input());
 
     app.update();
 
@@ -97,6 +101,7 @@ fn capture_and_playback() {
     let mut app = playback_app(PlaybackStrategy::default());
     app.add_plugins(InputCapturePlugin);
     app.insert_resource(PlaybackStrategy::Paused);
+    app.insert_resource(TimestampedInputs::default());
 
     let mut input_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     input_events.send(TEST_PRESS);
@@ -133,7 +138,8 @@ fn repeated_playback() {
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    *app.world_mut().resource_mut::<TimestampedInputs>() = simple_timestamped_input();
+    app.insert_resource(simple_timestamped_input());
+
     for _ in 1..10 {
         app.update();
     }
@@ -156,7 +162,7 @@ fn repeated_playback() {
 #[test]
 fn playback_strategy_paused() {
     let mut app = playback_app(PlaybackStrategy::Paused);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -172,7 +178,7 @@ fn playback_strategy_paused() {
 #[test]
 fn playback_strategy_frame() {
     let mut app = playback_app(PlaybackStrategy::FrameCount);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -199,7 +205,7 @@ fn playback_strategy_frame() {
 fn playback_strategy_frame_range_once() {
     let strategy = PlaybackStrategy::FrameRangeOnce(FrameCount(2), FrameCount(5));
     let mut app = playback_app(strategy);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -238,7 +244,7 @@ fn playback_strategy_frame_range_once() {
 fn playback_strategy_frame_range_loop() {
     let strategy = PlaybackStrategy::FrameRangeLoop(FrameCount(2), FrameCount(5));
     let mut app = playback_app(strategy);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);