diff --git a/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleBoundUserInterface.cs b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleBoundUserInterface.cs
new file mode 100644
index 00000000000..d416ff6e036
--- /dev/null
+++ b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleBoundUserInterface.cs
@@ -0,0 +1,67 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._WF.SafetyDepositBox.BUI;
+using Content.Shared._WF.SafetyDepositBox.Events;
+using Robust.Client.UserInterface;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._WF.SafetyDepositBox;
+
+public sealed class SafetyDepositConsoleBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables]
+    private SafetyDepositConsoleWindow? _window;
+
+    public SafetyDepositConsoleBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<SafetyDepositConsoleWindow>();
+        _window.Title = Loc.GetString("safety-deposit-console-title");
+        _window.OnPurchasePressed += OnPurchasePressed;
+        _window.OnDepositPressed += OnDepositPressed;
+        _window.OnWithdrawPressed += OnWithdrawPressed;
+        _window.OnReclaimPressed += OnReclaimPressed;
+    }
+
+    private void OnPurchasePressed(EntProtoId boxSize)
+    {
+        SendMessage(new SafetyDepositPurchaseMessage(boxSize));
+    }
+
+    private void OnDepositPressed()
+    {
+        SendMessage(new SafetyDepositDepositMessage());
+    }
+
+    private void OnWithdrawPressed(Guid boxId)
+    {
+        SendMessage(new SafetyDepositWithdrawMessage(boxId));
+    }
+
+    private void OnReclaimPressed(Guid boxId)
+    {
+        SendMessage(new SafetyDepositReclaimMessage(boxId));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (state is not SafetyDepositConsoleState castState)
+            return;
+
+        _window?.UpdateState(castState);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (disposing)
+            _window?.Dispose();
+    }
+}
diff --git a/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml
new file mode 100644
index 00000000000..4f0fe88f292
--- /dev/null
+++ b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml
@@ -0,0 +1,83 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="650 550"
+                      Title="{Loc 'safety-deposit-console-title'}">
+    <BoxContainer Orientation="Vertical" Margin="15">
+        <!-- Header -->
+        <Label Text="{Loc 'safety-deposit-console-header'}"
+               StyleClasses="LabelHeading"
+               Margin="0 0 0 15"
+               HorizontalAlignment="Center"/>
+
+        <!-- Top Action Cells -->
+        <BoxContainer Orientation="Horizontal" Margin="0 0 0 15" HorizontalExpand="True">
+            <!-- Purchase Box Cell -->
+            <PanelContainer StyleClasses="AngleRect" HorizontalExpand="True" Margin="0 0 5 0">
+                <BoxContainer Orientation="Vertical" Margin="15">
+                    <Label Text="{Loc 'safety-deposit-console-purchase-section'}"
+                           StyleClasses="LabelSubHeading"
+                           Margin="0 0 0 10"
+                           HorizontalAlignment="Center"/>
+                    <Label Text="{Loc 'safety-deposit-console-bank-payment-note'}"
+                           Margin="0 0 0 10"
+                           HorizontalAlignment="Center"
+                           StyleClasses="LabelSecondaryColor LabelSubText"/>
+                    <Button Name="PurchaseSmallButton"
+                            Text="{Loc 'safety-deposit-console-purchase-small'}"
+                            HorizontalAlignment="Stretch"
+                            MinSize="0 30"
+                            Margin="0 0 0 5"
+                            StyleClasses="OpenBoth"/>
+                    <Button Name="PurchaseMediumButton"
+                            Text="{Loc 'safety-deposit-console-purchase-medium'}"
+                            HorizontalAlignment="Stretch"
+                            MinSize="0 30"
+                            Margin="0 0 0 5"
+                            StyleClasses="OpenBoth"/>
+                    <Button Name="PurchaseLargeButton"
+                            Text="{Loc 'safety-deposit-console-purchase-large'}"
+                            HorizontalAlignment="Stretch"
+                            MinSize="0 30"
+                            StyleClasses="OpenBoth"/>
+                </BoxContainer>
+            </PanelContainer>
+
+            <!-- Deposit Box Cell -->
+            <PanelContainer StyleClasses="AngleRect" HorizontalExpand="True" Margin="5 0 0 0">
+                <BoxContainer Orientation="Vertical" Margin="15">
+                    <Label Text="{Loc 'safety-deposit-console-deposit-section'}"
+                           StyleClasses="LabelSubHeading"
+                           Margin="0 0 0 10"
+                           HorizontalAlignment="Center"/>
+                    <Label Name="BoxSlotLabel"
+                           Text="{Loc 'safety-deposit-console-no-box-in-slot'}"
+                           Margin="0 0 0 10"
+                           HorizontalAlignment="Center"
+                           StyleClasses="LabelSecondaryColor"/>
+                    <Button Name="DepositButton"
+                            Text="{Loc 'safety-deposit-console-deposit-button'}"
+                            HorizontalAlignment="Stretch"
+                            MinSize="0 35"
+                            StyleClasses="OpenBoth"/>
+                </BoxContainer>
+            </PanelContainer>
+        </BoxContainer>
+
+        <PanelContainer StyleClasses="AngleRect" MinSize="0 2" Margin="0 0 0 15"/>
+
+        <!-- Owned Boxes List -->
+        <BoxContainer Orientation="Vertical" VerticalExpand="True">
+            <Label Text="{Loc 'safety-deposit-console-owned-boxes'}"
+                   StyleClasses="LabelSubHeading"
+                   Margin="0 0 0 10"/>
+            <PanelContainer StyleClasses="AngleRect" VerticalExpand="True" ModulateSelfOverride="#0A0A0A">
+                <ScrollContainer VerticalExpand="True" Margin="5">
+                    <BoxContainer Name="OwnedBoxesContainer"
+                                  Orientation="Vertical"
+                                  VerticalExpand="True"
+                                  SeparationOverride="2"/>
+                </ScrollContainer>
+            </PanelContainer>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml.cs b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml.cs
new file mode 100644
index 00000000000..25452efb9d3
--- /dev/null
+++ b/Content.Client/_WF/SafetyDepositBox/SafetyDepositConsoleWindow.xaml.cs
@@ -0,0 +1,181 @@
+using System.Linq;
+using System.Numerics;
+using Content.Client.UserInterface.Controls;
+using Content.Shared._WF.SafetyDepositBox.BUI;
+using Content.Shared._WF.SafetyDepositBox.Components;
+using Content.Shared._WF.SafetyDepositBox.Events;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client._WF.SafetyDepositBox;
+
+[GenerateTypedNameReferences]
+public sealed partial class SafetyDepositConsoleWindow : FancyWindow
+{
+    public event Action<EntProtoId>? OnPurchasePressed;
+    public event Action? OnDepositPressed;
+    public event Action<Guid>? OnWithdrawPressed;
+    public event Action<Guid>? OnReclaimPressed;
+
+    public SafetyDepositConsoleWindow()
+    {
+        RobustXamlLoader.Load(this);
+
+        PurchaseSmallButton.OnPressed += _ => OnPurchasePressed?.Invoke("SafetyDepositBoxSmall");
+        PurchaseMediumButton.OnPressed += _ => OnPurchasePressed?.Invoke("SafetyDepositBoxMedium");
+        PurchaseLargeButton.OnPressed += _ => OnPurchasePressed?.Invoke("SafetyDepositBoxLarge");
+        DepositButton.OnPressed += _ => OnDepositPressed?.Invoke();
+    }
+
+    public void UpdateState(SafetyDepositConsoleState state)
+    {
+        // Update purchase buttons with costs
+
+        PurchaseSmallButton.Disabled = false; // Bank account check happens server-side
+        PurchaseSmallButton.Text = Loc.GetString("safety-deposit-console-purchase-small", ("cost", state.SmallBoxCost));
+
+        PurchaseMediumButton.Disabled = false;
+        PurchaseMediumButton.Text = Loc.GetString("safety-deposit-console-purchase-medium", ("cost", state.MediumBoxCost));
+
+        PurchaseLargeButton.Disabled = false;
+        PurchaseLargeButton.Text = Loc.GetString("safety-deposit-console-purchase-large", ("cost", state.LargeBoxCost));
+
+        // Update deposit button
+        DepositButton.Disabled = !state.HasBoxInSlot || state.BoxInSlot == null;
+
+        // Update box slot status
+        if (state.HasBoxInSlot && state.BoxInSlot != null)
+        {
+            BoxSlotLabel.Text = Loc.GetString("safety-deposit-console-box-in-slot",
+                ("id", state.BoxInSlot.Value.BoxId.ToString()[..8]));
+        }
+        else
+        {
+            BoxSlotLabel.Text = Loc.GetString("safety-deposit-console-no-box-in-slot");
+        }
+
+        // Update owned boxes list
+        OwnedBoxesContainer.RemoveAllChildren();
+
+        if (state.OwnedBoxes.Count == 0)
+        {
+            var noBoxesLabel = new Label
+            {
+                Text = Loc.GetString("safety-deposit-console-no-boxes"),
+                StyleClasses = { "LabelSecondaryColor" },
+                HorizontalAlignment = Control.HAlignment.Center,
+                Margin = new Thickness(0, 20)
+            };
+            OwnedBoxesContainer.AddChild(noBoxesLabel);
+        }
+        else
+        {
+            // Sort boxes newest first (by BoxId descending)
+            var sortedBoxes = state.OwnedBoxes.OrderByDescending(b => b.BoxId).ToList();
+
+            var index = 0;
+            foreach (var box in sortedBoxes)
+            {
+                // Create a clean row similar to shipyard
+                var rowPanel = new PanelContainer
+                {
+                    HorizontalExpand = true,
+                    StyleClasses = { "AngleRect" },
+                    // Alternate row colors for better readability
+                    ModulateSelfOverride = index % 2 == 0 ? new Color(0.15f, 0.15f, 0.15f) : new Color(0.12f, 0.12f, 0.12f)
+                };
+
+                var rowContainer = new BoxContainer
+                {
+                    Orientation = BoxContainer.LayoutOrientation.Horizontal,
+                    HorizontalExpand = true,
+                    Margin = new Thickness(8, 4)
+                };
+
+                // Box info label - shows nickname if available, otherwise box ID and size
+                var boxInfoText = !string.IsNullOrEmpty(box.Nickname)
+                    ? $"{box.Nickname}"
+                    : $"Box {box.BoxId.ToString()[..8]}";
+
+                var boxIdLabel = new Label
+                {
+                    Text = boxInfoText,
+                    HorizontalExpand = true,
+                    VerticalAlignment = Control.VAlignment.Center
+                };
+
+                // Status Label - fixed width, right aligned
+                string statusText;
+                Color statusColor;
+
+                if (box.IsDeposited)
+                {
+                    statusText = Loc.GetString("safety-deposit-console-box-deposited");
+                    statusColor = Color.LightGreen;
+                }
+                else if (box.LastWithdrawnRoundId.HasValue && box.LastWithdrawnRoundId.Value != state.CurrentRoundId)
+                {
+                    // Box was withdrawn in a previous round - it's lost
+                    statusText = Loc.GetString("safety-deposit-console-box-lost");
+                    statusColor = Color.Red;
+                }
+                else
+                {
+                    // Box was withdrawn in current round - it's in world
+                    statusText = Loc.GetString("safety-deposit-console-box-in-world");
+                    statusColor = Color.Yellow;
+                }
+
+                var statusLabel = new Label
+                {
+                    Text = statusText,
+                    MinWidth = 80,
+                    Align = Label.AlignMode.Right,
+                    Margin = new Thickness(0, 0, 5, 0),
+                    HorizontalAlignment = Control.HAlignment.Right,
+                    VerticalAlignment = Control.VAlignment.Center,
+                    FontColorOverride = statusColor
+                };
+
+                // Determine if box is lost (withdrawn in previous round with no items)
+                var isLost = box.LastWithdrawnRoundId.HasValue &&
+                             box.LastWithdrawnRoundId.Value != state.CurrentRoundId &&
+                             !box.IsDeposited;
+
+                // Action button - either Withdraw or Reclaim depending on state
+                var actionButton = new Button
+                {
+                    Text = isLost
+                        ? Loc.GetString("safety-deposit-console-reclaim-button")
+                        : Loc.GetString("safety-deposit-console-withdraw-button"),
+                    Disabled = !box.IsDeposited && !isLost,
+                    MinWidth = 100,
+                    HorizontalAlignment = Control.HAlignment.Right,
+                    VerticalAlignment = Control.VAlignment.Center
+                };
+
+                var boxId = box.BoxId;
+                if (isLost)
+                {
+                    actionButton.OnPressed += _ => OnReclaimPressed?.Invoke(boxId);
+                }
+                else
+                {
+                    actionButton.OnPressed += _ => OnWithdrawPressed?.Invoke(boxId);
+                }
+
+                rowContainer.AddChild(boxIdLabel);
+                rowContainer.AddChild(statusLabel);
+                rowContainer.AddChild(actionButton);
+                rowPanel.AddChild(rowContainer);
+                OwnedBoxesContainer.AddChild(rowPanel);
+
+                index++;
+            }
+        }
+    }
+}
diff --git a/Content.Server.Database/Model.cs b/Content.Server.Database/Model.cs
index abdf84496b2..718b93c41e6 100644
--- a/Content.Server.Database/Model.cs
+++ b/Content.Server.Database/Model.cs
@@ -57,6 +57,8 @@ protected ServerDbContext(DbContextOptions options) : base(options)
         public DbSet<TriadShipyardMigrationPermit>  TriadShipyardMigrationPermits   { get; set; } = default!;
         // End Triad
         public DbSet<CompanyMember> CompanyMembers { get; set; } = null!;
+        public DbSet<WayfarerSafetyDepositBox> WayfarerSafetyDepositBox { get; set; } = null!;
+        public DbSet<WayfarerSafetyDepositBoxItem> WayfarerSafetyDepositBoxItem { get; set; } = null!;
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
@@ -356,6 +358,23 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                 .HasForeignKey(w => w.PlayerUserId)
                 .HasPrincipalKey(p => p.UserId)
                 .OnDelete(DeleteBehavior.Cascade);
+
+            // Wayfarer Safety Deposit Box configuration
+            modelBuilder.Entity<WayfarerSafetyDepositBox>()
+                .HasIndex(b => b.BoxId)
+                .IsUnique();
+
+            modelBuilder.Entity<WayfarerSafetyDepositBox>()
+                .HasIndex(b => b.OwnerUserId);
+
+            modelBuilder.Entity<WayfarerSafetyDepositBoxItem>()
+                .HasOne(i => i.Box)
+                .WithMany(b => b.Items)
+                .HasForeignKey(i => i.BoxId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            modelBuilder.Entity<WayfarerSafetyDepositBoxItem>()
+                .HasIndex(i => i.BoxId);
         }
 
         public virtual IQueryable<AdminLog> SearchLogs(IQueryable<AdminLog> query, string searchText)
@@ -1290,4 +1309,89 @@ public class CompanyMember
         public string CompanyId { get; set; } = default!;
     }
     // Mono-End
+
+    // Wayfarer Safety Deposit Box Tables
+    public class WayfarerSafetyDepositBox
+    {
+        [Key]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Unique identifier for this deposit box
+        /// </summary>
+        public Guid BoxId { get; set; }
+
+        /// <summary>
+        /// The user ID of the owner
+        /// </summary>
+        public Guid OwnerUserId { get; set; }
+
+        /// <summary>
+        /// The character profile index (slot number) of the owner
+        /// </summary>
+        public int CharacterIndex { get; set; }
+
+        /// <summary>
+        /// Display name of the owner when the box was created
+        /// </summary>
+        [Required]
+        public string OwnerName { get; set; } = null!;
+
+        /// <summary>
+        /// Optional nickname for the box (from label)
+        /// </summary>
+        public string? Nickname { get; set; }
+
+        /// <summary>
+        /// Entity prototype for the box.
+        /// </summary>
+        [Required]
+        public string ProtoId { get; set; } = null!;
+
+        /// <summary>
+        /// When the box was purchased
+        /// </summary>
+        public DateTime PurchaseDate { get; set; }
+
+        /// <summary>
+        /// When the box was last withdrawn from the console. Null if currently stored in database.
+        /// Used to track boxes that are "in the world" vs "safely stored".
+        /// </summary>
+        public DateTime? LastWithdrawn { get; set; }
+
+        /// <summary>
+        /// The round ID when the box was last withdrawn. Null if currently stored in database.
+        /// Used to detect if a box was lost (withdrawn in a previous round but never deposited back).
+        /// </summary>
+        public int? LastWithdrawnRoundId { get; set; }
+
+        /// <summary>
+        /// Items stored in this box
+        /// </summary>
+        public List<WayfarerSafetyDepositBoxItem> Items { get; set; } = new();
+    }
+
+    public class WayfarerSafetyDepositBoxItem
+    {
+        [Key]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Foreign key to the deposit box
+        /// </summary>
+        public int BoxId { get; set; }
+
+        public WayfarerSafetyDepositBox Box { get; set; } = null!;
+
+        /// <summary>
+        /// Serialized entity data (YAML format)
+        /// </summary>
+        [Required]
+        public string EntityData { get; set; } = null!;
+
+        /// <summary>
+        /// When this item was deposited
+        /// </summary>
+        public DateTime DepositDate { get; set; }
+    }
 }
diff --git a/Content.Server/Administration/Commands/SafetyDepositBoxCommands.cs b/Content.Server/Administration/Commands/SafetyDepositBoxCommands.cs
new file mode 100644
index 00000000000..6fd77c6b788
--- /dev/null
+++ b/Content.Server/Administration/Commands/SafetyDepositBoxCommands.cs
@@ -0,0 +1,52 @@
+using Content.Server.Database;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+
+namespace Content.Server.Administration.Commands;
+
+[AdminCommand(AdminFlags.Admin)]
+public sealed partial class CleanStaleSafetyDepositBoxesCommand : IConsoleCommand
+{
+    [Dependency] private IServerDbManager _db = default!;
+
+    public string Command => "cleanstalesafetyboxes";
+    public string Description => "Deletes safety deposit boxes that have been withdrawn and have no items for more than the specified number of days.";
+    public string Help => "cleanstalesafetyboxes <days>\nExample: cleanstalesafetyboxes 7\nDeletes boxes that have been withdrawn for more than 7 days with no items.";
+
+    public async void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length != 1)
+        {
+            shell.WriteError("Usage: cleanstalesafetyboxes <days>");
+            return;
+        }
+
+        if (!int.TryParse(args[0], out var days) || days <= 0)
+        {
+            shell.WriteError("Days must be a positive integer.");
+            return;
+        }
+
+        shell.WriteLine($"Searching for safety deposit boxes that have been withdrawn for more than {days} days with no items...");
+
+        try
+        {
+            var count = await _db.DeleteStaleSafetyDepositBoxes(days);
+            shell.WriteLine($"Successfully deleted {count} stale safety deposit box(es).");
+        }
+        catch (Exception ex)
+        {
+            shell.WriteError($"Error cleaning stale boxes: {ex.Message}");
+        }
+    }
+
+    public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+    {
+        if (args.Length == 1)
+        {
+            return CompletionResult.FromHint("days (e.g., 7)");
+        }
+
+        return CompletionResult.Empty;
+    }
+}
diff --git a/Content.Server/Database/ServerDbBase.cs b/Content.Server/Database/ServerDbBase.cs
index 2d587a68eb2..1bc0e068054 100644
--- a/Content.Server/Database/ServerDbBase.cs
+++ b/Content.Server/Database/ServerDbBase.cs
@@ -2140,5 +2140,173 @@ private static async Task<IEnumerable<TResult>> AsyncSelect<T, TResult>(
 
             return [..results];
         }
+
+        #region Wayfarer Safety Deposit Box
+
+        public async Task<WayfarerSafetyDepositBox> PurchaseSafetyDepositBox(
+            Guid ownerUserId,
+            int characterIndex,
+            string ownerName,
+            EntProtoId protoId,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var box = new WayfarerSafetyDepositBox
+            {
+                BoxId = Guid.NewGuid(),
+                OwnerUserId = ownerUserId,
+                CharacterIndex = characterIndex,
+                OwnerName = ownerName,
+                ProtoId = protoId,
+                PurchaseDate = DateTime.UtcNow
+            };
+
+            db.DbContext.WayfarerSafetyDepositBox.Add(box);
+            await db.DbContext.SaveChangesAsync(cancel);
+
+            return box;
+        }
+
+        public async Task<List<WayfarerSafetyDepositBox>> GetPlayerSafetyDepositBoxes(
+            Guid ownerUserId,
+            int characterIndex,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            return await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .Where(b => b.OwnerUserId == ownerUserId && b.CharacterIndex == characterIndex)
+                .ToListAsync(cancel);
+        }
+
+        public async Task<WayfarerSafetyDepositBox?> GetSafetyDepositBox(
+            Guid boxId,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            return await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .FirstOrDefaultAsync(b => b.BoxId == boxId, cancel);
+        }
+
+        public async Task DepositSafetyDepositBoxItems(
+            Guid boxId,
+            List<string> entityDataList,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var box = await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .FirstOrDefaultAsync(b => b.BoxId == boxId, cancel);
+
+            if (box == null)
+                return;
+
+            // Clear existing items
+            db.DbContext.WayfarerSafetyDepositBoxItem.RemoveRange(box.Items);
+
+            // Add new items
+            foreach (var entityData in entityDataList)
+            {
+                box.Items.Add(new WayfarerSafetyDepositBoxItem
+                {
+                    BoxId = box.Id,
+                    EntityData = entityData,
+                    DepositDate = DateTime.UtcNow
+                });
+            }
+
+            // Clear LastWithdrawn since the box is now safely stored
+            box.LastWithdrawn = null;
+            box.LastWithdrawnRoundId = null;
+
+            await db.DbContext.SaveChangesAsync(cancel);
+        }
+
+        public async Task UpdateSafetyDepositBoxNickname(
+            Guid boxId,
+            string? nickname,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var box = await db.DbContext.WayfarerSafetyDepositBox
+                .FirstOrDefaultAsync(b => b.BoxId == boxId, cancel);
+
+            if (box == null)
+                return;
+
+            box.Nickname = nickname;
+            await db.DbContext.SaveChangesAsync(cancel);
+        }
+
+        public async Task ClearSafetyDepositBoxItems(
+            Guid boxId,
+            int roundId,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var box = await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .FirstOrDefaultAsync(b => b.BoxId == boxId, cancel);
+
+            if (box == null)
+                return;
+
+            db.DbContext.WayfarerSafetyDepositBoxItem.RemoveRange(box.Items);
+
+            // Set LastWithdrawn to indicate the box is now in the world
+            box.LastWithdrawn = DateTime.UtcNow;
+            box.LastWithdrawnRoundId = roundId;
+
+            await db.DbContext.SaveChangesAsync(cancel);
+        }
+
+        public async Task<int> DeleteStaleSafetyDepositBoxes(
+            int daysStale,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var cutoffDate = DateTime.UtcNow.AddDays(-daysStale);
+
+            // Find boxes that have been withdrawn and have no items for longer than the cutoff period
+            var staleBoxes = await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .Where(b => b.LastWithdrawn != null &&
+                            b.LastWithdrawn < cutoffDate &&
+                            b.Items.Count == 0)
+                .ToListAsync(cancel);
+
+            var count = staleBoxes.Count;
+            db.DbContext.WayfarerSafetyDepositBox.RemoveRange(staleBoxes);
+            await db.DbContext.SaveChangesAsync(cancel);
+
+            return count;
+        }
+
+        public async Task DeleteSafetyDepositBox(
+            Guid boxId,
+            CancellationToken cancel = default)
+        {
+            await using var db = await GetDb(cancel);
+
+            var box = await db.DbContext.WayfarerSafetyDepositBox
+                .Include(b => b.Items)
+                .FirstOrDefaultAsync(b => b.BoxId == boxId, cancel);
+
+            if (box == null)
+                return;
+
+            db.DbContext.WayfarerSafetyDepositBox.Remove(box);
+            await db.DbContext.SaveChangesAsync(cancel);
+        }
+
+        #endregion
     }
 }
diff --git a/Content.Server/Database/ServerDbManager.cs b/Content.Server/Database/ServerDbManager.cs
index b0b6b97ad3e..ad5381f49a9 100644
--- a/Content.Server/Database/ServerDbManager.cs
+++ b/Content.Server/Database/ServerDbManager.cs
@@ -364,6 +364,19 @@ Task<int> AddConnectionLogAsync(
 
         #endregion
 
+        #region Wayfarer Safety Deposit Box
+
+        Task<WayfarerSafetyDepositBox> PurchaseSafetyDepositBox(Guid ownerUserId, int characterIndex, string ownerName, string boxSize, CancellationToken cancel = default);
+        Task<List<WayfarerSafetyDepositBox>> GetPlayerSafetyDepositBoxes(Guid ownerUserId, int characterIndex, CancellationToken cancel = default);
+        Task<WayfarerSafetyDepositBox?> GetSafetyDepositBox(Guid boxId, CancellationToken cancel = default);
+        Task DepositSafetyDepositBoxItems(Guid boxId, List<string> entityDataList, CancellationToken cancel = default);
+        Task UpdateSafetyDepositBoxNickname(Guid boxId, string? nickname, CancellationToken cancel = default);
+        Task ClearSafetyDepositBoxItems(Guid boxId, int roundId, CancellationToken cancel = default);
+        Task<int> DeleteStaleSafetyDepositBoxes(int daysStale, CancellationToken cancel = default);
+        Task DeleteSafetyDepositBox(Guid boxId, CancellationToken cancel = default);
+
+        #endregion
+
         // Triad: tamper protection
         #region Triad
         /// <summary>
@@ -1120,6 +1133,58 @@ public Task SendNotification(DatabaseNotification notification)
             return RunDbCommand(() => _db.SendNotification(notification));
         }
 
+        #region Wayfarer Safety Deposit Box
+
+        public Task<WayfarerSafetyDepositBox> PurchaseSafetyDepositBox(Guid ownerUserId, int characterIndex, string ownerName, string boxSize, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.PurchaseSafetyDepositBox(ownerUserId, characterIndex, ownerName, boxSize, cancel));
+        }
+
+        public Task<List<WayfarerSafetyDepositBox>> GetPlayerSafetyDepositBoxes(Guid ownerUserId, int characterIndex, CancellationToken cancel = default)
+        {
+            DbReadOpsMetric.Inc();
+            return RunDbCommand(() => _db.GetPlayerSafetyDepositBoxes(ownerUserId, characterIndex, cancel));
+        }
+
+        public Task<WayfarerSafetyDepositBox?> GetSafetyDepositBox(Guid boxId, CancellationToken cancel = default)
+        {
+            DbReadOpsMetric.Inc();
+            return RunDbCommand(() => _db.GetSafetyDepositBox(boxId, cancel));
+        }
+
+        public Task DepositSafetyDepositBoxItems(Guid boxId, List<string> entityDataList, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.DepositSafetyDepositBoxItems(boxId, entityDataList, cancel));
+        }
+
+        public Task UpdateSafetyDepositBoxNickname(Guid boxId, string? nickname, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.UpdateSafetyDepositBoxNickname(boxId, nickname, cancel));
+        }
+
+        public Task ClearSafetyDepositBoxItems(Guid boxId, int roundId, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.ClearSafetyDepositBoxItems(boxId, roundId, cancel));
+        }
+
+        public Task<int> DeleteStaleSafetyDepositBoxes(int daysStale, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.DeleteStaleSafetyDepositBoxes(daysStale, cancel));
+        }
+
+        public Task DeleteSafetyDepositBox(Guid boxId, CancellationToken cancel = default)
+        {
+            DbWriteOpsMetric.Inc();
+            return RunDbCommand(() => _db.DeleteSafetyDepositBox(boxId, cancel));
+        }
+
+        #endregion
+
         private async void HandleDatabaseNotification(DatabaseNotification notification)
         {
             lock (_notificationHandlers)
diff --git a/Content.Server/_WF/SafetyDepositBox/SafetyDepositBoxSystem.cs b/Content.Server/_WF/SafetyDepositBox/SafetyDepositBoxSystem.cs
new file mode 100644
index 00000000000..3daab088e38
--- /dev/null
+++ b/Content.Server/_WF/SafetyDepositBox/SafetyDepositBoxSystem.cs
@@ -0,0 +1,623 @@
+using System.IO;
+using Content.Server.Administration.Logs;
+using Content.Server.Database;
+using Content.Server.GameTicking;
+using Content.Server.Hands.Systems;
+using Content.Server.Popups;
+using Content.Server.Preferences.Managers;
+using Content.Server._NF.Bank;
+using Content.Shared._NF.Bank.Components;
+using Content.Shared._WF.SafetyDepositBox.BUI;
+using Content.Shared._WF.SafetyDepositBox.Components;
+using Content.Shared._WF.SafetyDepositBox.Events;
+using Content.Shared.Database;
+using Content.Shared.Storage;
+using Content.Shared.Storage.EntitySystems;
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Labels.Components;
+using Content.Shared.Labels.EntitySystems;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Containers;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Shared.Serialization.Manager;
+
+namespace Content.Server._WF.SafetyDepositBox;
+
+public sealed partial class SafetyDepositBoxSystem : EntitySystem
+{
+    [Dependency] private IPrototypeManager _prototypeManager = default!;
+    [Dependency] private SharedAudioSystem _audio = default!;
+    [Dependency] private PopupSystem _popup = default!;
+    [Dependency] private BankSystem _bankSystem = default!;
+    [Dependency] private UserInterfaceSystem _uiSystem = default!;
+    [Dependency] private IAdminLogManager _adminLogger = default!;
+    [Dependency] private HandsSystem _hands = default!;
+    [Dependency] private TransformSystem _transform = default!;
+    [Dependency] private IServerDbManager _dbManager = default!;
+    [Dependency] private SharedStorageSystem _storage = default!;
+    [Dependency] private ItemSlotsSystem _itemSlots = default!;
+    [Dependency] private SharedLabelSystem _label = default!; // Wicce: LabelSystem -> SharedLabelSystem
+    [Dependency] private IServerPreferencesManager _prefsManager = default!;
+    [Dependency] private GameTicker _gameTicker = default!;
+    [Dependency] private IComponentFactory _componentFactory = default!;
+    [Dependency] private MapLoaderSystem _loader = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, ComponentInit>(OnConsoleInit);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, BoundUIOpenedEvent>(OnUIOpen);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, SafetyDepositPurchaseMessage>(OnPurchase);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, SafetyDepositDepositMessage>(OnDeposit);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, SafetyDepositWithdrawMessage>(OnWithdraw);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, SafetyDepositReclaimMessage>(OnReclaim);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, EntInsertedIntoContainerMessage>(OnSlotChanged);
+        SubscribeLocalEvent<SafetyDepositConsoleComponent, EntRemovedFromContainerMessage>(OnSlotChanged);
+    }
+
+    private void OnConsoleInit(EntityUid uid, SafetyDepositConsoleComponent component, ComponentInit args)
+    {
+        _itemSlots.AddItemSlot(uid, SafetyDepositConsoleComponent.BoxSlotId, component.BoxSlot);
+    }
+
+    private void OnUIOpen(EntityUid uid, SafetyDepositConsoleComponent component, BoundUIOpenedEvent args)
+    {
+        if (args.Actor is not { Valid: true } player)
+            return;
+
+        UpdateUI(uid, component, player);
+    }
+
+    private async void UpdateUI(EntityUid consoleUid, SafetyDepositConsoleComponent component, EntityUid player)
+    {
+        if (!TryComp<ActorComponent>(player, out var actor))
+            return;
+
+        var userId = actor.PlayerSession.UserId;
+        if (!_prefsManager.TryGetCachedPreferences(userId, out var prefs))
+            return;
+
+        var characterIndex = prefs.SelectedCharacterIndex;
+
+        // Get all boxes owned by this character from database
+        var ownedBoxes = await _dbManager.GetPlayerSafetyDepositBoxes(userId.UserId, characterIndex);
+
+        var boxInfoList = new List<SafetyDepositBoxInfo>();
+        foreach (var box in ownedBoxes)
+        {
+            // A box is considered deposited if:
+            // - It has never been withdrawn (!LastWithdrawn.HasValue), OR
+            // - It was withdrawn in the current round and still has items
+            // A box is considered lost if it was withdrawn in a previous round and has no items
+            bool isDeposited;
+            if (!box.LastWithdrawn.HasValue)
+                isDeposited = true;
+            else if (box.LastWithdrawnRoundId.HasValue && box.LastWithdrawnRoundId.Value != _gameTicker.RoundId)
+            {
+                // Withdrawn in a previous round - lost regardless of items
+                isDeposited = false;
+            }
+            else
+            {
+                // Withdrawn in current round - deposited only if it has items
+                isDeposited = box.Items.Count > 0;
+            }
+
+            boxInfoList.Add(new (
+                box.BoxId,
+                box.OwnerName,
+                isDeposited,
+                box.Nickname,
+                box.ProtoId,
+                box.LastWithdrawn,
+                box.LastWithdrawnRoundId
+            ));
+        }
+
+        var boxInSlot = component.BoxSlot.Item;
+        SafetyDepositBoxInfo? boxInSlotInfo = null;
+
+        if (boxInSlot != null && TryComp<SafetyDepositBoxComponent>(boxInSlot, out var boxComp) && boxComp.BoxId.HasValue)
+        {
+            // Get label if it exists
+            string? nickname = null;
+            if (TryComp<LabelComponent>(boxInSlot.Value, out var labelComp))
+            {
+                nickname = labelComp.CurrentLabel;
+            }
+
+            if (!TryPrototype(boxInSlot.Value, out var boxProto))
+                return;
+
+            boxInSlotInfo = new SafetyDepositBoxInfo(
+                boxComp.BoxId.Value,
+                boxComp.OwnerName ?? "Unknown",
+                false,
+                nickname,
+                boxProto.ToString(),
+                null,
+                null
+            );
+        }
+
+        var state = new SafetyDepositConsoleState(
+            boxInfoList,
+            0, // No cash display needed anymore
+            boxInSlot != null,
+            boxInSlotInfo,
+            GetBoxCost(component.SmallBoxProto),
+            GetBoxCost(component.MediumBoxProto),
+            GetBoxCost(component.LargeBoxProto),
+            _gameTicker.RoundId
+        );
+
+        _uiSystem.SetUiState(consoleUid, SafetyDepositConsoleUiKey.Key, state);
+    }
+
+    private void OnPurchase(EntityUid uid, SafetyDepositConsoleComponent component, SafetyDepositPurchaseMessage args)
+    {
+        int cost;
+        EntityPrototype prototypeId;
+        if (args.Actor is not { Valid: true } player)
+            return;
+
+        if (!TryComp<ActorComponent>(player, out var actor))
+            return;
+
+        if (_prototypeManager.TryIndex(args.BoxProto, out var proto) && proto.TryGetComponent<SafetyDepositBoxComponent>(out var boxComponent, _componentFactory))
+        {
+            cost = boxComponent.Cost;
+            prototypeId = proto;
+        }
+        else
+        {
+            ConsolePopup(player, "Error: Invalid box size.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        // Check bank account
+        if (!TryComp<BankAccountComponent>(player, out var bank))
+        {
+            ConsolePopup(player, "Error: No bank account found.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        if (bank.Balance < cost)
+        {
+            ConsolePopup(player, $"Insufficient funds. You need ${cost:N0}, but only have ${bank.Balance:N0}.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        // Withdraw from bank
+        if (!_bankSystem.TryBankWithdraw(player, cost))
+        {
+            ConsolePopup(player, "Transaction failed.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        // Create the box in the database
+        var userId = actor.PlayerSession.UserId;
+        if (!_prefsManager.TryGetCachedPreferences(userId, out var prefs))
+        {
+            ConsolePopup(player, "Error: Could not load character data.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        var characterIndex = prefs.SelectedCharacterIndex;
+        var characterName = MetaData(player).EntityName;
+
+        PurchaseBoxAsync(uid, component, player, userId.UserId, characterIndex, characterName, prototypeId, cost);
+    }
+
+    // got tired of doing this
+    public int GetBoxCost(EntProtoId boxProto)
+    {
+        if (_prototypeManager.TryIndex(boxProto, out var proto) &&
+            proto.TryGetComponent<SafetyDepositBoxComponent>(out var boxComponent, _componentFactory))
+            return boxComponent.Cost;
+        else
+            return 0;
+    }
+
+    private async void PurchaseBoxAsync(
+        EntityUid consoleUid,
+        SafetyDepositConsoleComponent component,
+        EntityUid player,
+        Guid userId,
+        int characterIndex,
+        string characterName,
+        EntityPrototype prototypeId,
+        int cost)
+    {
+        // Create box in database
+        var box = await _dbManager.PurchaseSafetyDepositBox(userId, characterIndex, characterName, prototypeId.ID);
+
+        // Spawn the physical box
+        var boxEntity = Spawn(prototypeId.ID, Transform(player).Coordinates);
+        var boxComp = EnsureComp<SafetyDepositBoxComponent>(boxEntity);
+
+        boxComp.BoxId = box.BoxId;
+        boxComp.OwnerId = userId;
+        boxComp.CharacterIndex = characterIndex;
+        boxComp.OwnerName = characterName;
+        Dirty(boxEntity, boxComp);
+
+        // Try to put it in player's hands
+        if (!_hands.TryPickupAnyHand(player, boxEntity))
+        {
+            _transform.SetLocalRotation(boxEntity, Angle.Zero);
+        }
+
+        // Mark the box as withdrawn so it shows "In World" in the UI
+        await _dbManager.ClearSafetyDepositBoxItems(box.BoxId, _gameTicker.RoundId);
+
+        ConsolePopup(player, $"Safety deposit box purchased! Box ID: {box.BoxId.ToString()[..8]}...");
+        PlayConfirmSound(consoleUid, component);
+
+        _adminLogger.Add(LogType.Action, LogImpact.Medium,
+            $"{ToPrettyString(player):actor} purchased safety deposit box {box.BoxId} for {cost} credits");
+
+        UpdateUI(consoleUid, component, player);
+    }
+
+    private void OnDeposit(EntityUid uid, SafetyDepositConsoleComponent component, SafetyDepositDepositMessage args)
+    {
+        if (args.Actor is not { Valid: true } player)
+            return;
+
+        if (!TryComp<ActorComponent>(player, out var actor))
+            return;
+
+        // Check if there's a box in the slot
+        var boxEntity = component.BoxSlot.Item;
+        if (boxEntity == null)
+        {
+            ConsolePopup(player, "Please insert a safety deposit box.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        if (!TryComp<SafetyDepositBoxComponent>(boxEntity.Value, out var boxComp) || !boxComp.BoxId.HasValue)
+        {
+            ConsolePopup(player, "Invalid safety deposit box.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        // Verify ownership
+        var userId = actor.PlayerSession.UserId;
+        if (!_prefsManager.TryGetCachedPreferences(userId, out var prefs))
+        {
+            ConsolePopup(player, "Error: Could not load character data.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        var characterIndex = prefs.SelectedCharacterIndex;
+        if (boxComp.OwnerId != userId.UserId || boxComp.CharacterIndex != characterIndex)
+        {
+            ConsolePopup(player, "This box does not belong to you.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        // Serialize the contents
+        if (!TryComp<StorageComponent>(boxEntity.Value, out var storageComp))
+        {
+            ConsolePopup(player, "Error: Box has no storage.");
+            PlayDenySound(uid, component);
+            return;
+        }
+
+        DepositBoxAsync(uid, component, player, boxEntity.Value, boxComp, storageComp);
+    }
+
+    private async void DepositBoxAsync(
+        EntityUid consoleUid,
+        SafetyDepositConsoleComponent component,
+        EntityUid player,
+        EntityUid boxEntity,
+        SafetyDepositBoxComponent boxComp,
+        StorageComponent storageComp)
+    {
+        var entityDataList = new List<string>();
+
+        Log.Info($"DepositBoxAsync: Box has {storageComp.Container.ContainedEntities.Count} items");
+
+        // Serialize each item in the box - store prototype + component data
+        foreach (var item in storageComp.Container.ContainedEntities)
+        {
+            try
+            {
+                Log.Info($"Serializing item: {ToPrettyString(item)}");
+                using var writer = new StringWriter();
+                _loader.TrySaveEntity(item, writer);
+                entityDataList.Add(writer.ToString());
+            }
+            catch (Exception ex)
+            {
+                Log.Error($"Failed to serialize item {ToPrettyString(item)} in safety deposit box: {ex}");
+            }
+        }
+
+        Log.Info($"Saving {entityDataList.Count} items to database for box {boxComp.BoxId}");
+
+        // Get nickname from label if it exists
+        string? nickname = null;
+        if (TryComp<LabelComponent>(boxEntity, out var boxLabel) && !string.IsNullOrEmpty(boxLabel.CurrentLabel))
+        {
+            nickname = boxLabel.CurrentLabel;
+            Log.Info($"Saving box nickname: {nickname}");
+        }
+
+        // Save to database
+        await _dbManager.DepositSafetyDepositBoxItems(boxComp.BoxId!.Value, entityDataList);
+
+        // Update nickname if one was set
+        if (nickname != null)
+        {
+            await _dbManager.UpdateSafetyDepositBoxNickname(boxComp.BoxId!.Value, nickname);
+        }
+
+        // Remove from slot before deleting to properly update UI
+        _itemSlots.TryEject(consoleUid, component.BoxSlot, null, out _);
+
+        // Delete the physical box
+        QueueDel(boxEntity);
+
+        ConsolePopup(player, "Safety deposit box contents saved. The box has been stored.");
+        PlayConfirmSound(consoleUid, component);
+
+        _adminLogger.Add(LogType.Action, LogImpact.Medium,
+            $"{ToPrettyString(player):actor} deposited safety deposit box {boxComp.BoxId} with {storageComp.Container.ContainedEntities.Count} items");
+
+        UpdateUI(consoleUid, component, player);
+    }
+
+    private void OnWithdraw(EntityUid uid, SafetyDepositConsoleComponent component, SafetyDepositWithdrawMessage args)
+    {
+        if (args.Actor is not { Valid: true } player)
+            return;
+
+        if (!TryComp<ActorComponent>(player, out var actor))
+            return;
+
+        var userId = actor.PlayerSession.UserId;
+        if (!_prefsManager.TryGetCachedPreferences(userId, out var prefs))
+            return;
+
+        var characterIndex = prefs.SelectedCharacterIndex;
+
+        WithdrawBoxAsync(uid, component, player, userId.UserId, characterIndex, args.BoxId);
+    }
+
+    private void OnReclaim(EntityUid uid, SafetyDepositConsoleComponent component, SafetyDepositReclaimMessage args)
+    {
+        if (args.Actor is not { Valid: true } player)
+            return;
+
+        if (!TryComp<ActorComponent>(player, out var actor))
+            return;
+
+        var userId = actor.PlayerSession.UserId;
+        if (!_prefsManager.TryGetCachedPreferences(userId, out var prefs))
+            return;
+
+        var characterIndex = prefs.SelectedCharacterIndex;
+
+        ReclaimBoxAsync(uid, component, player, userId.UserId, characterIndex, args.BoxId);
+    }
+
+    private async void ReclaimBoxAsync(
+        EntityUid consoleUid,
+        SafetyDepositConsoleComponent component,
+        EntityUid player,
+        Guid userId,
+        int characterIndex,
+        Guid boxId)
+    {
+        // Get box from database
+        var box = await _dbManager.GetSafetyDepositBox(boxId);
+
+        if (box == null)
+        {
+            ConsolePopup(player, "Box not found.");
+            PlayDenySound(consoleUid, component);
+            return;
+        }
+
+        // Verify ownership
+        if (box.OwnerUserId != userId || box.CharacterIndex != characterIndex)
+        {
+            ConsolePopup(player, "This box does not belong to you.");
+            PlayDenySound(consoleUid, component);
+            return;
+        }
+
+        // Verify box is actually lost (withdrawn in previous round with no items)
+        bool isLost = box.LastWithdrawn.HasValue &&
+                      box.LastWithdrawnRoundId.HasValue &&
+                      box.LastWithdrawnRoundId.Value != _gameTicker.RoundId &&
+                      box.Items.Count == 0;
+
+        if (!isLost)
+        {
+            ConsolePopup(player, "This box is not lost and cannot be reclaimed.");
+            PlayDenySound(consoleUid, component);
+            return;
+        }
+
+        // Delete the database record
+        await _dbManager.DeleteSafetyDepositBox(boxId);
+
+        // Create a new database record for the replacement box
+        var newBox = await _dbManager.PurchaseSafetyDepositBox(
+            userId,
+            characterIndex,
+            MetaData(player).EntityName,
+            box.ProtoId
+        );
+
+        // Spawn a new empty physical box
+        string prototypeId = box.ProtoId;
+
+        var boxEntity = Spawn(prototypeId, Transform(player).Coordinates);
+        var boxComp = EnsureComp<SafetyDepositBoxComponent>(boxEntity);
+        boxComp.BoxId = newBox.BoxId;
+        boxComp.OwnerId = userId;
+        boxComp.CharacterIndex = characterIndex;
+        boxComp.OwnerName = MetaData(player).EntityName;
+        Dirty(boxEntity, boxComp);
+
+        // Mark the box as withdrawn in the current round (since we're giving them a physical box)
+        await _dbManager.ClearSafetyDepositBoxItems(newBox.BoxId, _gameTicker.RoundId);
+
+        // Restore nickname if one was saved
+        if (!string.IsNullOrEmpty(box.Nickname))
+        {
+            _label.Label(boxEntity, box.Nickname);
+        }
+
+        // Try to put it in player's hands
+        if (!_hands.TryPickupAnyHand(player, boxEntity))
+        {
+            _transform.SetLocalRotation(boxEntity, Angle.Zero);
+        }
+
+        ConsolePopup(player, "Lost box reclaimed! A new empty box has been issued.");
+        PlayConfirmSound(consoleUid, component);
+
+        _adminLogger.Add(LogType.Action, LogImpact.Medium,
+            $"{ToPrettyString(player):actor} reclaimed lost safety deposit box {boxId}");
+
+        UpdateUI(consoleUid, component, player);
+    }
+
+    private async void WithdrawBoxAsync(
+        EntityUid consoleUid,
+        SafetyDepositConsoleComponent component,
+        EntityUid player,
+        Guid userId,
+        int characterIndex,
+        Guid boxId)
+    {
+        // Get box from database
+        var box = await _dbManager.GetSafetyDepositBox(boxId);
+
+        if (box == null)
+        {
+            ConsolePopup(player, "Box not found.");
+            PlayDenySound(consoleUid, component);
+            return;
+        }
+
+        Log.Info($"WithdrawBoxAsync: Retrieved box {boxId} with {box.Items.Count} items from database");
+
+        // Verify ownership
+        if (box.OwnerUserId != userId || box.CharacterIndex != characterIndex)
+        {
+            ConsolePopup(player, "This box does not belong to you.");
+            PlayDenySound(consoleUid, component);
+            return;
+        }
+
+        // Spawn the physical box (use stored box size to determine prototype);
+
+        var boxEntity = Spawn(box.ProtoId, Transform(player).Coordinates);
+        var boxComp = EnsureComp<SafetyDepositBoxComponent>(boxEntity);
+        boxComp.BoxId = box.BoxId;
+        boxComp.OwnerId = userId;
+        boxComp.CharacterIndex = characterIndex;
+        // Use current character name instead of stored name in case they changed it
+        boxComp.OwnerName = MetaData(player).EntityName;
+        Dirty(boxEntity, boxComp);
+
+        // Restore nickname if one was saved
+        if (!string.IsNullOrEmpty(box.Nickname))
+        {
+            _label.Label(boxEntity, box.Nickname);
+            Log.Info($"Restored box nickname: {box.Nickname}");
+        }
+
+        // Deserialize and spawn items into the box
+        if (TryComp<StorageComponent>(boxEntity, out var storageComp))
+        {
+            foreach (var itemData in box.Items)
+            {
+                try
+                {
+                    using var reader = new StringReader(itemData.EntityData);
+                    if (!_loader.TryLoadEntity(reader, "safety deposit box", out var entity))
+                        return;
+
+                    var itemEntity = entity.Value.Owner;
+                    // Mark item as having been stored in a deposit box
+                    EnsureComp<SafetyDepositStoredComponent>(itemEntity);
+
+                    // Insert into storage
+                    if (!_storage.Insert(boxEntity, itemEntity, out _, storageComp: storageComp, playSound: false))
+                        QueueDel(itemEntity);
+
+                }
+                catch (Exception ex)
+                {
+                    Log.Error($"Failed to deserialize item from safety deposit box {boxId}: {ex}");
+                }
+            }
+        }
+        else
+        {
+            Log.Error($"Box entity {boxEntity} has no StorageComponent!");
+        }
+
+        // Clear items from database
+        await _dbManager.ClearSafetyDepositBoxItems(boxId, _gameTicker.RoundId);
+
+        // Try to put it in player's hands or place it near them
+        if (!_hands.TryPickupAnyHand(player, boxEntity))
+        {
+            _transform.SetLocalRotation(boxEntity, Angle.Zero);
+        }
+
+        ConsolePopup(player, "Safety deposit box retrieved.");
+        PlayConfirmSound(consoleUid, component);
+
+        _adminLogger.Add(LogType.Action, LogImpact.Medium,
+            $"{ToPrettyString(player):actor} withdrew safety deposit box {boxId} with {box.Items.Count} items");
+
+        UpdateUI(consoleUid, component, player);
+    }
+
+    private void OnSlotChanged(EntityUid uid, SafetyDepositConsoleComponent component, ContainerModifiedMessage args)
+    {
+        // Update UI for anyone who has this console's UI open
+        foreach (var actor in _uiSystem.GetActors(uid, SafetyDepositConsoleUiKey.Key))
+        {
+            UpdateUI(uid, component, actor);
+        }
+    }
+
+    private void PlayDenySound(EntityUid uid, SafetyDepositConsoleComponent component)
+    {
+        _audio.PlayPvs(component.ErrorSound, uid);
+    }
+
+    private void PlayConfirmSound(EntityUid uid, SafetyDepositConsoleComponent component)
+    {
+        _audio.PlayPvs(component.ConfirmSound, uid);
+    }
+
+    private void ConsolePopup(EntityUid actor, string text)
+    {
+        _popup.PopupEntity(text, actor, actor);
+    }
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleState.cs b/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleState.cs
new file mode 100644
index 00000000000..f6e1a607878
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleState.cs
@@ -0,0 +1,85 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._WF.SafetyDepositBox.BUI;
+
+/// <summary>
+/// State of the safety deposit console UI
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class SafetyDepositConsoleState : BoundUserInterfaceState
+{
+    /// <summary>
+    /// List of boxes owned by the current user.
+    /// </summary>
+    public List<SafetyDepositBoxInfo> OwnedBoxes = new();
+
+    /// <summary>
+    /// Amount of cash currently inserted in the console.
+    /// </summary>
+    public int InsertedCash;
+
+    /// <summary>
+    /// Is there a box currently in the box slot?
+    /// </summary>
+    public bool HasBoxInSlot;
+
+    /// <summary>
+    /// Info about the box in the slot, if any.
+    /// </summary>
+    public SafetyDepositBoxInfo? BoxInSlot;
+
+    /// <summary>
+    /// Purchase cost for a small box.
+    /// </summary>
+    public int SmallBoxCost;
+
+    /// <summary>
+    /// Purchase cost for a medium box.
+    /// </summary>
+    public int MediumBoxCost;
+
+    /// <summary>
+    /// Purchase cost for a large box.
+    /// </summary>
+    public int LargeBoxCost;
+
+    /// <summary>
+    /// The current round ID, used to determine if boxes are lost.
+    /// </summary>
+    public int CurrentRoundId;
+
+    public SafetyDepositConsoleState(
+        List<SafetyDepositBoxInfo> ownedBoxes,
+        int insertedCash,
+        bool hasBoxInSlot,
+        SafetyDepositBoxInfo? boxInSlot,
+        int smallBoxCost,
+        int mediumBoxCost,
+        int largeBoxCost,
+        int currentRoundId)
+    {
+        OwnedBoxes = ownedBoxes;
+        InsertedCash = insertedCash;
+        HasBoxInSlot = hasBoxInSlot;
+        BoxInSlot = boxInSlot;
+        SmallBoxCost = smallBoxCost;
+        MediumBoxCost = mediumBoxCost;
+        LargeBoxCost = largeBoxCost;
+        CurrentRoundId = currentRoundId;
+    }
+}
+
+/// <summary>
+/// Information about a safety deposit box.
+/// </summary>
+[Serializable, NetSerializable]
+public record struct SafetyDepositBoxInfo(
+    Guid BoxId,
+    string OwnerName,
+    bool IsDeposited,
+    string? Nickname,
+    string ProtoId,
+    DateTime? LastWithdrawn,
+    int? LastWithdrawnRoundId
+);
diff --git a/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleUiKey.cs b/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleUiKey.cs
new file mode 100644
index 00000000000..3cc8b781603
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/BUI/SafetyDepositConsoleUiKey.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._WF.SafetyDepositBox.BUI;
+
+[Serializable, NetSerializable]
+public enum SafetyDepositConsoleUiKey : byte
+{
+    Key
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositBoxComponent.cs b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositBoxComponent.cs
new file mode 100644
index 00000000000..9bf8a7d8d96
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositBoxComponent.cs
@@ -0,0 +1,49 @@
+using Content.Shared.Storage;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._WF.SafetyDepositBox.Components;
+
+/// <summary>
+/// A physical box that stores items and can be deposited into a console for persistence.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SafetyDepositBoxComponent : Component
+{
+    /// <summary>
+    /// Unique ID for this deposit box, assigned when purchased.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public Guid? BoxId;
+
+    /// <summary>
+    /// The user ID of the owner of this box.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public Guid? OwnerId;
+
+    /// <summary>
+    /// The character profile index (slot number) of the owner.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public int? CharacterIndex;
+
+    /// <summary>
+    /// Display name of the owner.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public string? OwnerName;
+
+    /// <summary>
+    /// I think you get the idea.
+    /// </summary>
+    [DataField(required:true), ViewVariables(VVAccess.ReadWrite)]
+    public int Cost;
+}
+
+[Serializable, NetSerializable]
+public enum SafetyDepositBoxVisuals : byte
+{
+    Locked,
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositConsoleComponent.cs b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositConsoleComponent.cs
new file mode 100644
index 00000000000..df495fee45f
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositConsoleComponent.cs
@@ -0,0 +1,47 @@
+using Content.Shared.Containers.ItemSlots;
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._WF.SafetyDepositBox.Components;
+
+/// <summary>
+/// Console for purchasing, depositing, and withdrawing safety deposit boxes.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SafetyDepositConsoleComponent : Component
+{
+    /// <summary>
+    /// Slot for depositing/withdrawing boxes.
+    /// </summary>
+    [DataField]
+    public ItemSlot BoxSlot = new();
+
+    /// <summary>
+    /// Entity to use for small boxes.
+    /// </summary>
+    [DataField(required:true)]
+    public EntProtoId SmallBoxProto;
+
+    /// <summary>
+    /// Entity to use for medium boxes.
+    /// </summary>
+    [DataField(required: true)]
+    public EntProtoId MediumBoxProto;
+
+    /// <summary>
+    /// Entity to use for large boxes.
+    /// </summary>
+    [DataField(required:true)]
+    public EntProtoId LargeBoxProto;
+
+    public static string BoxSlotId = "safety-deposit-console-boxSlot";
+
+    [DataField]
+    public SoundSpecifier ErrorSound =
+        new SoundPathSpecifier("/Audio/Effects/Cargo/buzz_sigh.ogg");
+
+    [DataField]
+    public SoundSpecifier ConfirmSound =
+        new SoundPathSpecifier("/Audio/Effects/Cargo/ping.ogg");
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositStoredComponent.cs b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositStoredComponent.cs
new file mode 100644
index 00000000000..cc6792a295f
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/Components/SafetyDepositStoredComponent.cs
@@ -0,0 +1,12 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._WF.SafetyDepositBox.Components;
+
+/// <summary>
+/// Marks an item as having been stored in a safety deposit box at some point.
+/// Shows up in examine text.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SafetyDepositStoredComponent : Component
+{
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/Events/SafetyDepositMessages.cs b/Content.Shared/_WF/SafetyDepositBox/Events/SafetyDepositMessages.cs
new file mode 100644
index 00000000000..889ce5ff184
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/Events/SafetyDepositMessages.cs
@@ -0,0 +1,54 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._WF.SafetyDepositBox.Events;
+
+/// <summary>
+/// Message to purchase a new safety deposit box.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class SafetyDepositPurchaseMessage : BoundUserInterfaceMessage
+{
+    public EntProtoId BoxProto;
+
+    public SafetyDepositPurchaseMessage(EntProtoId boxProto)
+    {
+        BoxProto = boxProto;
+    }
+}
+
+/// <summary>
+/// Message to deposit a box into the console.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class SafetyDepositDepositMessage : BoundUserInterfaceMessage
+{
+}
+
+/// <summary>
+/// Message to withdraw a specific box from storage.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class SafetyDepositWithdrawMessage : BoundUserInterfaceMessage
+{
+    public Guid BoxId;
+
+    public SafetyDepositWithdrawMessage(Guid boxId)
+    {
+        BoxId = boxId;
+    }
+}
+
+/// <summary>
+/// Message to reclaim a lost box (delete old record and spawn new empty box).
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class SafetyDepositReclaimMessage : BoundUserInterfaceMessage
+{
+    public Guid BoxId;
+
+    public SafetyDepositReclaimMessage(Guid boxId)
+    {
+        BoxId = boxId;
+    }
+}
diff --git a/Content.Shared/_WF/SafetyDepositBox/SafetyDepositStoredSystem.cs b/Content.Shared/_WF/SafetyDepositBox/SafetyDepositStoredSystem.cs
new file mode 100644
index 00000000000..f9a04d9336d
--- /dev/null
+++ b/Content.Shared/_WF/SafetyDepositBox/SafetyDepositStoredSystem.cs
@@ -0,0 +1,34 @@
+using Content.Shared._WF.SafetyDepositBox.Components;
+using Content.Shared.Examine;
+using Robust.Shared.Utility;
+
+namespace Content.Shared._WF.SafetyDepositBox;
+
+public sealed partial class SafetyDepositStoredSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<SafetyDepositStoredComponent, ExaminedEvent>(OnStoredExamined);
+        SubscribeLocalEvent<SafetyDepositBoxComponent, ExaminedEvent>(OnBoxExamined);
+    }
+
+    private void OnStoredExamined(Entity<SafetyDepositStoredComponent> ent, ref ExaminedEvent args)
+    {
+        args.PushMarkup(Loc.GetString("safety-deposit-stored-examine"));
+    }
+
+    private void OnBoxExamined(Entity<SafetyDepositBoxComponent> ent, ref ExaminedEvent args)
+    {
+        if (ent.Comp.BoxId.HasValue)
+        {
+            var shortId = ent.Comp.BoxId.Value.ToString()[..8];
+            args.PushMarkup(Loc.GetString("safety-deposit-box-examine-id", ("id", shortId)));
+        }
+
+        if (!string.IsNullOrEmpty(ent.Comp.OwnerName))
+        {
+            args.PushMarkup(Loc.GetString("safety-deposit-box-examine-owner", ("owner", ent.Comp.OwnerName)));
+        }
+    }
+}
diff --git a/Resources/Locale/en-US/_NF/guidebook/guides.ftl b/Resources/Locale/en-US/_NF/guidebook/guides.ftl
index 2126e70f069..be1f0c90126 100644
--- a/Resources/Locale/en-US/_NF/guidebook/guides.ftl
+++ b/Resources/Locale/en-US/_NF/guidebook/guides.ftl
@@ -1,6 +1,7 @@
 # Base entries
 guide-entry-nf14 = Frontier Guide
 guide-entry-bank = Andromeda Central Bank
+guide-entry-safety-deposit-box = Safety Deposit Box System
 guide-entry-piloting = Piloting
 guide-entry-startinggear = Starting Equipment
 guide-entry-hiring = Hiring Crew
diff --git a/Resources/Locale/en-US/_WF/safety-deposit-box.ftl b/Resources/Locale/en-US/_WF/safety-deposit-box.ftl
new file mode 100644
index 00000000000..cbe063d0292
--- /dev/null
+++ b/Resources/Locale/en-US/_WF/safety-deposit-box.ftl
@@ -0,0 +1,31 @@
+# Safety Deposit Box Console UI
+safety-deposit-console-title = Safety Deposit Box Console
+safety-deposit-console-header = Safety Deposit Box Management
+safety-deposit-console-purchase-section = Purchase New Box
+safety-deposit-console-bank-payment-note = Cost will be deducted from your bank account.
+safety-deposit-console-purchase-small = Small (2x2) - ${$cost}
+safety-deposit-console-purchase-medium = Medium (2x4) - ${$cost}
+safety-deposit-console-purchase-large = Large (2x6) - ${$cost}
+safety-deposit-console-deposit-section = Deposit Box
+safety-deposit-console-box-in-slot = Box {$id} in slot
+safety-deposit-console-no-box-in-slot = No box in slot
+safety-deposit-console-deposit-button = Deposit Box
+safety-deposit-console-withdraw-button = Withdraw
+safety-deposit-console-reclaim-button = Reclaim
+safety-deposit-console-owned-boxes = Your Safety Deposit Boxes:
+safety-deposit-console-no-boxes = You don't own any safety deposit boxes yet.
+safety-deposit-console-box-id = Box ID: {$id}... - {$status}
+safety-deposit-console-box-id-short = Box ID: {$id}...
+safety-deposit-console-box-deposited = Stored
+safety-deposit-console-box-not-deposited = Not Stored
+safety-deposit-console-box-in-world = In World
+safety-deposit-console-box-lost = Lost
+
+# Safety Deposit Box Entity
+safety-deposit-box-boxSlot = Box Slot
+safety-deposit-console-boxSlot = Box Slot
+
+# Examine text
+safety-deposit-stored-examine = [color=gray]This item has a signature on it that indicates that it was at one point stowed in a deposit box.[/color]
+safety-deposit-box-examine-id = [color=cyan]Box ID:[/color] {$id}...
+safety-deposit-box-examine-owner = [color=yellow]Owner:[/color] {$owner}
diff --git a/Resources/Prototypes/_NF/Guidebook/nf14.yml b/Resources/Prototypes/_NF/Guidebook/nf14.yml
index c7f5c93b753..b1db8ef47a8 100644
--- a/Resources/Prototypes/_NF/Guidebook/nf14.yml
+++ b/Resources/Prototypes/_NF/Guidebook/nf14.yml
@@ -5,6 +5,7 @@
   priority: -1
   children: # note: children may be in other files. When adding to this, update the priority of anything after.
   - Bank
+  - SafetyDepositBox
   - Hiring
   - Piloting
   - Survival # Moved out from Station and Shifts section (upstream file)
@@ -22,6 +23,12 @@
   text: "/ServerInfo/_NF/Guidebook/Bank.xml"
   priority: 0
 
+- type: guideEntry
+  id: SafetyDepositBox
+  name: guide-entry-safety-deposit-box
+  text: "/ServerInfo/_NF/Guidebook/SafetyDepositBox.xml"
+  priority: 0
+
 - type: guideEntry
   id: Hiring
   name: guide-entry-hiring
diff --git a/Resources/Prototypes/_WF/Entities/Structures/Machines/safety_deposit_box.yml b/Resources/Prototypes/_WF/Entities/Structures/Machines/safety_deposit_box.yml
new file mode 100644
index 00000000000..76d8561772c
--- /dev/null
+++ b/Resources/Prototypes/_WF/Entities/Structures/Machines/safety_deposit_box.yml
@@ -0,0 +1,127 @@
+# Safety Deposit Box Entities
+
+# Base parent for all safety deposit boxes
+- type: entity
+  id: SafetyDepositBoxBase
+  abstract: true
+  parent: BaseStorageItem
+  components:
+  - type: GenericVisualizer
+    visuals:
+      enum.StorageVisuals.Open:
+        base:
+          True: { state: icon-open }
+          False: { state: icon }
+  - type: Storage
+    blacklist:
+      components:
+      - IdCard
+      - Currency
+      - Store
+      - EncryptionKey
+      - Implant
+      - Storage
+      - SafetyDepositBox
+      tags:
+      - SavingContraband
+  - type: SafetyDepositBox
+  - type: Appearance
+  - type: Tag
+    tags:
+    - SafetyDepositBox
+
+- type: entity
+  id: SafetyDepositBoxSmall
+  name: safety deposit box (small)
+  description: A small secure box for storing valuables. Can hold 2x2 items.
+  parent: SafetyDepositBoxBase
+  components:
+  - type: Sprite
+    sprite: _WF/Objects/Economy/depositboxsmall.rsi
+    state: icon
+  - type: Item
+    size: Small
+  - type: SafetyDepositBox
+    cost: 2000000
+  - type: Storage
+    maxItemSize: Small
+    grid:
+    - 0,0,1,1
+
+- type: entity
+  id: SafetyDepositBoxMedium
+  name: safety deposit box (medium)
+  description: A medium secure box for storing valuables. Can hold 2x4 items.
+  parent: SafetyDepositBoxBase
+  components:
+  - type: Sprite
+    sprite: _WF/Objects/Economy/depositboxmedium.rsi
+    state: icon
+  - type: Item
+    size: Normal
+  - type: SafetyDepositBox
+    cost: 3500000
+  - type: Storage
+    maxItemSize: Normal
+    grid:
+    - 0,0,1,3
+
+- type: entity
+  id: SafetyDepositBoxLarge
+  name: safety deposit box (large)
+  description: A large secure box for storing valuables. Can hold 2x6 items.
+  parent: SafetyDepositBoxBase
+  components:
+  - type: Sprite
+    sprite: _WF/Objects/Economy/depositboxlarge.rsi
+    state: icon
+  - type: Item
+    size: Large
+  - type: SafetyDepositBox
+    cost: 5000000
+  - type: Storage
+    maxItemSize: Large
+    grid:
+    - 0,0,1,5
+
+- type: entity
+  id: SafetyDepositConsole
+  name: safety deposit box console
+  description: "A console for purchasing and managing safety deposit boxes."
+  parent: BaseStructure
+  components:
+  - type: Sprite
+    netsync: false
+    noRot: true
+    sprite: _WF/Structures/Machines/atm/depositatm.rsi
+    layers:
+    - map: ["computerLayerBody"]
+      state: icon
+    - map: ["computerLayerScreen"]
+      state: unshaded
+  - type: SafetyDepositConsole
+    smallBoxProto: SafetyDepositBoxSmall
+    mediumBoxProto: SafetyDepositBoxMedium
+    largeBoxProto: SafetyDepositBoxLarge
+    boxSlot:
+      name: safety-deposit-console-boxSlot
+      insertSound: /Audio/Machines/scanning.ogg
+      ejectSound: /Audio/Machines/tray_eject.ogg
+      ejectOnBreak: true
+      swap: false
+      whitelist:
+        tags:
+        - SafetyDepositBox
+  - type: ItemSlots
+  - type: ContainerContainer
+    containers:
+      safety-deposit-console-boxSlot: !type:ContainerSlot
+  - type: ActivatableUI
+    key: enum.SafetyDepositConsoleUiKey.Key
+  - type: InteractionOutline
+  - type: UserInterface
+    interfaces:
+      enum.SafetyDepositConsoleUiKey.Key:
+        type: SafetyDepositConsoleBoundUserInterface
+  - type: Anchorable
+  - type: Pullable
diff --git a/Resources/Prototypes/_WF/tags.yml b/Resources/Prototypes/_WF/tags.yml
new file mode 100644
index 00000000000..8e862f1a298
--- /dev/null
+++ b/Resources/Prototypes/_WF/tags.yml
@@ -0,0 +1,4 @@
+# Wayfarer Tags
+
+- type: Tag
+  id: SafetyDepositBox
diff --git a/Resources/ServerInfo/_NF/Guidebook/SafetyDepositBox.xml b/Resources/ServerInfo/_NF/Guidebook/SafetyDepositBox.xml
new file mode 100644
index 00000000000..52b24706f66
--- /dev/null
+++ b/Resources/ServerInfo/_NF/Guidebook/SafetyDepositBox.xml
@@ -0,0 +1,87 @@
+<Document>
+  # Safety Deposit Box System
+
+The [color=#44cc00]Safety Deposit Box System[/color] allows you to securely store items across shifts in a persistent database. Your stored items will remain available even after the round ends or the server restarts.
+
+## Safety Deposit Console
+  <Box>
+    <GuideEntityEmbed Entity="SafetyDepositConsole"/>
+  </Box>
+  The [color=#44cc00]Safety Deposit Console[/color] is your interface for managing your deposit boxes. Located at Camelot and Caelestinius Central's shipyards, it allows you to:
+- [bold]Purchase[/bold] new safety deposit boxes
+- [bold]Deposit[/bold] boxes to store items in the database
+- [bold]Withdraw[/bold] stored boxes to retrieve your items
+- [bold]Reclaim[/bold] lost boxes that were never returned
+
+## Box Sizes and Pricing
+  <Box>
+    <GuideEntityEmbed Entity="SafetyDepositBoxSmall"/>
+    <GuideEntityEmbed Entity="SafetyDepositBoxMedium"/>
+    <GuideEntityEmbed Entity="SafetyDepositBoxLarge"/>
+  </Box>
+  Three box sizes are available, each with different storage capacity:
+- [bold]Small (2x2)[/bold] - $2,000,000
+- [bold]Medium (2x4)[/bold] - $3,500,000
+- [bold]Large (2x6)[/bold] - $5,000,000
+
+The cost is deducted from your [color=#44cc00]bank account[/color] when you purchase a box.
+
+## How to Use
+
+### Purchasing a Box
+1. Access a [color=#44cc00]Safety Deposit Console[/color]
+2. Select the size you want (Small, Medium, or Large)
+3. The cost will be deducted from your bank account
+4. A physical box will spawn for you to use
+
+### Storing Items
+1. Place items inside your safety deposit box
+2. Insert the box into the console's [color=#33bbff]box slot[/color]
+3. Click the [bold]Deposit Box[/bold] button
+4. Your items are now safely stored in the database!
+
+The physical box will be consumed when deposited, but your items are now protected across shifts.
+
+### Retrieving Items
+1. Access a [color=#44cc00]Safety Deposit Console[/color]
+2. Find your box in the list (boxes show as [color=#00ff00]"Stored"[/color] when they have items)
+3. Click the [bold]Withdraw[/bold] button
+4. A physical box containing your items will spawn
+
+[color=#ff6600]Important:[/color] Once withdrawn, the box and items exist in the world. If you lose the box or it's destroyed before re-depositing, your items are gone!
+
+## Box Status Indicators
+
+Your boxes can have several status indicators:
+- [color=#00ff00][bold]Stored[/bold][/color] - Box has items safely stored in the database
+- [color=#ffff00][bold]In World[/bold][/color] - Box was withdrawn recently (less than 7 days ago)
+- [color=#ff0000][bold]Lost (Empty)[/bold][/color] - Box was withdrawn over 7 days ago and never returned
+
+## Reclaiming Lost Boxes
+
+If you lost a box after withdrawing it (disconnected, round ended, etc.), and it shows as [color=#ff0000]"Lost (Empty)"[/color]:
+1. Access a [color=#44cc00]Safety Deposit Console[/color]
+2. Find the lost box in your list
+3. Click the [bold]Reclaim[/bold] button
+4. A new empty box with the same ID will be issued to you
+
+[color=#ff6600]Note:[/color] Reclaiming removes the old database record. Any items that were in the box when it was lost are gone permanently.
+
+## Tips and Best Practices
+
+- [bold]Label your boxes[/bold] - Use a hand labeler to give your boxes nicknames for easy identification
+- [bold]Deposit before leaving[/bold] - Always re-deposit your boxes before ending your shift
+- [bold]Keep valuables safe[/bold] - Store important documents, rare items, or valuable equipment
+- [bold]Multiple boxes[/bold] - You can own multiple boxes to organize different types of items
+- [bold]ID cards can't be stored[/bold] - The system won't allow ID cards to be deposited for security reasons
+
+## Item Preservation
+
+The safety deposit system preserves:
+- [bold]Paper content[/bold] - Written documents, stamps, and signatures
+- [bold]Labels[/bold] - Custom names you've applied to items
+- [bold]Stack counts[/bold] - The exact number of items in stacks
+- [bold]Box nicknames[/bold] - Custom labels on the boxes themselves
+
+Most items can be stored, but some sensitive items (like ID cards) are blacklisted for security reasons.
+</Document>
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon-open.png b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon-open.png
new file mode 100644
index 00000000000..7bd3961bb96
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon-open.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon.png b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon.png
new file mode 100644
index 00000000000..4b1fe018b34
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/icon.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-left.png b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-left.png
new file mode 100644
index 00000000000..a755ba0e30f
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-left.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-right.png b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-right.png
new file mode 100644
index 00000000000..3d989dacb5b
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/inhand-right.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/meta.json b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/meta.json
new file mode 100644
index 00000000000..eed62f7f2ea
--- /dev/null
+++ b/Resources/Textures/_WF/Objects/Economy/depositboxlarge.rsi/meta.json
@@ -0,0 +1,25 @@
+{
+  "version": 1,
+  "license": "CC0-1.0",
+  "copyright": "Sprites made by RobynIsBlue / Cuffle for Wayfarer 14",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    },
+    {
+      "name": "icon"
+    },
+    {
+      "name": "icon-open"
+    }
+  ]
+}
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon-open.png b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon-open.png
new file mode 100644
index 00000000000..1238fbe5304
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon-open.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon.png b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon.png
new file mode 100644
index 00000000000..cd962d4fdb9
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/icon.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-left.png b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-left.png
new file mode 100644
index 00000000000..a755ba0e30f
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-left.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-right.png b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-right.png
new file mode 100644
index 00000000000..3d989dacb5b
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/inhand-right.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/meta.json b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/meta.json
new file mode 100644
index 00000000000..eed62f7f2ea
--- /dev/null
+++ b/Resources/Textures/_WF/Objects/Economy/depositboxmedium.rsi/meta.json
@@ -0,0 +1,25 @@
+{
+  "version": 1,
+  "license": "CC0-1.0",
+  "copyright": "Sprites made by RobynIsBlue / Cuffle for Wayfarer 14",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    },
+    {
+      "name": "icon"
+    },
+    {
+      "name": "icon-open"
+    }
+  ]
+}
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon-open.png b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon-open.png
new file mode 100644
index 00000000000..3442b31605b
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon-open.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon.png b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon.png
new file mode 100644
index 00000000000..fed30618163
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/icon.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-left.png b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-left.png
new file mode 100644
index 00000000000..f1db6808405
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-left.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-right.png b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-right.png
new file mode 100644
index 00000000000..ee96d34c83d
Binary files /dev/null and b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/inhand-right.png differ
diff --git a/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/meta.json b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/meta.json
new file mode 100644
index 00000000000..eed62f7f2ea
--- /dev/null
+++ b/Resources/Textures/_WF/Objects/Economy/depositboxsmall.rsi/meta.json
@@ -0,0 +1,25 @@
+{
+  "version": 1,
+  "license": "CC0-1.0",
+  "copyright": "Sprites made by RobynIsBlue / Cuffle for Wayfarer 14",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    },
+    {
+      "name": "icon"
+    },
+    {
+      "name": "icon-open"
+    }
+  ]
+}
diff --git a/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/icon.png b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/icon.png
new file mode 100644
index 00000000000..3f6f8317719
Binary files /dev/null and b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/icon.png differ
diff --git a/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/meta.json b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/meta.json
new file mode 100644
index 00000000000..ff757493fb1
--- /dev/null
+++ b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/meta.json
@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "license": "CC0-1.0",
+  "copyright": "Created by EmoGarbage, reshaded by Checkraze, modified by RobynIsBlue / Cuffle for Wayfarer 14",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "icon"
+    },
+    {
+      "name": "printing",
+      "delays": [[0.25, 0.25, 0.25, 0.25]]
+    },
+    {
+      "name": "unshaded"
+    }
+  ]
+}
diff --git a/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/printing.png b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/printing.png
new file mode 100644
index 00000000000..e3943878950
Binary files /dev/null and b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/printing.png differ
diff --git a/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/unshaded.png b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/unshaded.png
new file mode 100644
index 00000000000..7ddf45e109d
Binary files /dev/null and b/Resources/Textures/_WF/Structures/Machines/atm/depositatm.rsi/unshaded.png differ