diff --git a/docs/reference/manual/hcloud.md b/docs/reference/manual/hcloud.md
index 5af7c33e..c4fe1f87 100644
--- a/docs/reference/manual/hcloud.md
+++ b/docs/reference/manual/hcloud.md
@@ -42,6 +42,7 @@ A command-line interface for Hetzner Cloud
 * [hcloud server](hcloud_server.md)	 - Manage Servers
 * [hcloud server-type](hcloud_server-type.md)	 - View Server Types
 * [hcloud ssh-key](hcloud_ssh-key.md)	 - Manage SSH Keys
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
 * [hcloud storage-box-type](hcloud_storage-box-type.md)	 - View Storage Box Types
 * [hcloud version](hcloud_version.md)	 - Print version information
 * [hcloud volume](hcloud_volume.md)	 - Manage Volumes
diff --git a/docs/reference/manual/hcloud_storage-box.md b/docs/reference/manual/hcloud_storage-box.md
new file mode 100644
index 00000000..dd7033b5
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box.md
@@ -0,0 +1,35 @@
+## hcloud storage-box
+
+Manage Storage Boxes
+
+### Options
+
+```
+  -h, --help   help for storage-box
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud](hcloud.md)	 - Hetzner Cloud CLI
+* [hcloud storage-box add-label](hcloud_storage-box_add-label.md)	 - Add a label to a Storage Box
+* [hcloud storage-box create](hcloud_storage-box_create.md)	 - Create a new Storage Box
+* [hcloud storage-box delete](hcloud_storage-box_delete.md)	 - Delete a Storage Box
+* [hcloud storage-box describe](hcloud_storage-box_describe.md)	 - Describe a Storage Box
+* [hcloud storage-box folders](hcloud_storage-box_folders.md)	 - List folders of a Storage Box
+* [hcloud storage-box list](hcloud_storage-box_list.md)	 - List Storage Boxes
+* [hcloud storage-box remove-label](hcloud_storage-box_remove-label.md)	 - Remove a label from a Storage Box
+* [hcloud storage-box update](hcloud_storage-box_update.md)	 - Update a Storage Box
diff --git a/docs/reference/manual/hcloud_storage-box_add-label.md b/docs/reference/manual/hcloud_storage-box_add-label.md
new file mode 100644
index 00000000..b8fe7bef
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_add-label.md
@@ -0,0 +1,32 @@
+## hcloud storage-box add-label
+
+Add a label to a Storage Box
+
+```
+hcloud storage-box add-label [--overwrite] <storage-box> <label>...
+```
+
+### Options
+
+```
+  -h, --help        help for add-label
+  -o, --overwrite   Overwrite label if it exists already (true, false)
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_create.md b/docs/reference/manual/hcloud_storage-box_create.md
new file mode 100644
index 00000000..f45ba22a
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_create.md
@@ -0,0 +1,44 @@
+## hcloud storage-box create
+
+Create a new Storage Box
+
+```
+hcloud storage-box create [options] --name <name> --type <type> --location <location> --password <password>
+```
+
+### Options
+
+```
+      --enable-protection strings   Enable protection (delete) (default: none)
+      --enable-samba                Whether the Samba subsystem should be enabled
+      --enable-ssh                  Whether the SSH subsystem should be enabled
+      --enable-webdav               Whether the WebDAV subsystem should be enabled
+      --enable-zfs                  Whether the ZFS Snapshot folder should be visible
+  -h, --help                        help for create
+      --label stringToString        User-defined labels ('key=value') (can be specified multiple times) (default [])
+      --location string             Location (ID or name) (required)
+      --name string                 Storage Box name (required)
+  -o, --output stringArray          output options: json|yaml
+      --password string             The password that will be set for this Storage Box (required)
+      --reachable-externally        Whether the Storage Box should be accessible from outside the Hetzner network
+      --ssh-key stringArray         SSH public keys in OpenSSH format or as the ID or name of an existing SSH key
+      --type string                 Storage Box Type (ID or name) (required)
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_delete.md b/docs/reference/manual/hcloud_storage-box_delete.md
new file mode 100644
index 00000000..458ac5d9
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_delete.md
@@ -0,0 +1,31 @@
+## hcloud storage-box delete
+
+Delete a Storage Box
+
+```
+hcloud storage-box delete <storage-box>...
+```
+
+### Options
+
+```
+  -h, --help   help for delete
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_describe.md b/docs/reference/manual/hcloud_storage-box_describe.md
new file mode 100644
index 00000000..74ad94da
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_describe.md
@@ -0,0 +1,32 @@
+## hcloud storage-box describe
+
+Describe a Storage Box
+
+```
+hcloud storage-box describe [options] <storage-box>
+```
+
+### Options
+
+```
+  -h, --help                 help for describe
+  -o, --output stringArray   output options: json|yaml|format
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_folders.md b/docs/reference/manual/hcloud_storage-box_folders.md
new file mode 100644
index 00000000..82806904
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_folders.md
@@ -0,0 +1,33 @@
+## hcloud storage-box folders
+
+List folders of a Storage Box
+
+```
+hcloud storage-box folders <storage-box>
+```
+
+### Options
+
+```
+  -h, --help                 help for folders
+  -o, --output stringArray   output options: json|yaml
+      --path string          Relative path for which the listing is to be made
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_list.md b/docs/reference/manual/hcloud_storage-box_list.md
new file mode 100644
index 00000000..fbc4c562
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_list.md
@@ -0,0 +1,56 @@
+## hcloud storage-box list
+
+List Storage Boxes
+
+### Synopsis
+
+Displays a list of Storage Boxes.
+
+Output can be controlled with the -o flag. Use -o noheader to suppress the
+table header. Displayed columns and their order can be set with
+-o columns=age,created (see available columns below).
+
+Columns:
+ - age
+ - created
+ - id
+ - labels
+ - location
+ - name
+ - server
+ - size
+ - status
+ - system
+ - type
+ - username
+
+```
+hcloud storage-box list [options]
+```
+
+### Options
+
+```
+  -h, --help                 help for list
+  -o, --output stringArray   output options: noheader|columns=...|json|yaml
+  -l, --selector string      Selector to filter by labels
+  -s, --sort strings         Determine the sorting of the result
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_remove-label.md b/docs/reference/manual/hcloud_storage-box_remove-label.md
new file mode 100644
index 00000000..cbfccaea
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_remove-label.md
@@ -0,0 +1,32 @@
+## hcloud storage-box remove-label
+
+Remove a label from a Storage Box
+
+```
+hcloud storage-box remove-label <storage-box> (--all | <label>...)
+```
+
+### Options
+
+```
+  -a, --all    Remove all labels
+  -h, --help   help for remove-label
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/docs/reference/manual/hcloud_storage-box_update.md b/docs/reference/manual/hcloud_storage-box_update.md
new file mode 100644
index 00000000..fcb37b01
--- /dev/null
+++ b/docs/reference/manual/hcloud_storage-box_update.md
@@ -0,0 +1,32 @@
+## hcloud storage-box update
+
+Update a Storage Box
+
+```
+hcloud storage-box update [options] <storage-box>
+```
+
+### Options
+
+```
+  -h, --help          help for update
+      --name string   Storage Box name
+```
+
+### Options inherited from parent commands
+
+```
+      --config string              Config file path (default "~/.config/hcloud/cli.toml")
+      --context string             Currently active context
+      --debug                      Enable debug output
+      --debug-file string          File to write debug output to
+      --endpoint string            Hetzner Cloud API endpoint (default "https://api.hetzner.cloud/v1")
+      --hetzner-endpoint string    Hetzner API endpoint (default "https://api.hetzner.com/v1")
+      --no-experimental-warnings   If true, experimental warnings are not shown
+      --poll-interval duration     Interval at which to poll information, for example action progress (default 500ms)
+      --quiet                      If true, only print error messages
+```
+
+### SEE ALSO
+
+* [hcloud storage-box](hcloud_storage-box.md)	 - Manage Storage Boxes
diff --git a/go.mod b/go.mod
index 5f8c5c80..6ad88cb2 100644
--- a/go.mod
+++ b/go.mod
@@ -65,4 +65,4 @@ require (
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
-replace github.com/hetznercloud/hcloud-go/v2 => github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250902143326-ace27a0a28dc
+replace github.com/hetznercloud/hcloud-go/v2 => github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250908103136-a25d71b20732
diff --git a/go.sum b/go.sum
index 5646df99..e562a703 100644
--- a/go.sum
+++ b/go.sum
@@ -37,8 +37,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/guptarohit/asciigraph v0.7.3 h1:p05XDDn7cBTWiBqWb30mrwxd6oU0claAjqeytllnsPY=
 github.com/guptarohit/asciigraph v0.7.3/go.mod h1:dYl5wwK4gNsnFf9Zp+l06rFiDZ5YtXM6x7SRWZ3KGag=
-github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250902143326-ace27a0a28dc h1:vAz2KQ8aJFsaHz7AJRkT38hjKnsgPpup3tjWnZn4lXc=
-github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250902143326-ace27a0a28dc/go.mod h1:rDpBO6bbG1aP6wcScPCOx880e7EB4uRxDYhQ/+qE/+w=
+github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250908103136-a25d71b20732 h1:gQ0IvtSLuLigEg+njl0vqElx+cEDHkDWRTBCnqgmjlE=
+github.com/hetznercloud/hcloud-go/v2 v2.22.1-0.20250908103136-a25d71b20732/go.mod h1:rDpBO6bbG1aP6wcScPCOx880e7EB4uRxDYhQ/+qE/+w=
 github.com/iancoleman/orderedmap v0.3.0 h1:5cbR2grmZR/DiVt+VJopEhtVs9YGInGIxAoMJn+Ichc=
 github.com/iancoleman/orderedmap v0.3.0/go.mod h1:XuLcCUkdL5owUCQeF2Ue9uuw1EptkJDkXXS7VoV7XGE=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
diff --git a/internal/cli/root.go b/internal/cli/root.go
index cd1bc1d1..6a7e1df4 100644
--- a/internal/cli/root.go
+++ b/internal/cli/root.go
@@ -24,6 +24,7 @@ import (
 	"github.com/hetznercloud/cli/internal/cmd/server"
 	"github.com/hetznercloud/cli/internal/cmd/servertype"
 	"github.com/hetznercloud/cli/internal/cmd/sshkey"
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
 	"github.com/hetznercloud/cli/internal/cmd/storageboxtype"
 	"github.com/hetznercloud/cli/internal/cmd/util"
 	"github.com/hetznercloud/cli/internal/cmd/version"
@@ -61,6 +62,7 @@ func NewRootCommand(s state.State) *cobra.Command {
 		firewall.NewCommand(s),
 		placementgroup.NewCommand(s),
 		primaryip.NewCommand(s),
+		storagebox.NewCommand(s),
 		storageboxtype.NewCommand(s),
 	)
 
diff --git a/internal/cmd/storagebox/create.go b/internal/cmd/storagebox/create.go
new file mode 100644
index 00000000..63e50cd6
--- /dev/null
+++ b/internal/cmd/storagebox/create.go
@@ -0,0 +1,138 @@
+package storagebox
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"golang.org/x/crypto/ssh"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/cmd/cmpl"
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var CreateCmd = base.CreateCmd[*hcloud.StorageBox]{
+	BaseCobraCommand: func(client hcapi2.Client) *cobra.Command {
+		cmd := &cobra.Command{
+			Use:   "create [options] --name <name> --type <type> --location <location> --password <password>",
+			Short: `Create a new Storage Box`,
+		}
+
+		cmd.Flags().String("name", "", "Storage Box name (required)")
+		_ = cmd.MarkFlagRequired("name")
+
+		cmd.Flags().String("type", "", "Storage Box Type (ID or name) (required)")
+		_ = cmd.RegisterFlagCompletionFunc("type", cmpl.SuggestCandidatesF(client.StorageBoxType().Names))
+		_ = cmd.MarkFlagRequired("type")
+
+		cmd.Flags().String("location", "", "Location (ID or name) (required)")
+		_ = cmd.MarkFlagRequired("location")
+		_ = cmd.RegisterFlagCompletionFunc("location", cmpl.SuggestCandidatesF(client.Location().Names))
+
+		cmd.Flags().String("password", "", "The password that will be set for this Storage Box (required)")
+		_ = cmd.MarkFlagRequired("password")
+
+		cmd.Flags().StringToString("label", nil, "User-defined labels ('key=value') (can be specified multiple times)")
+
+		cmd.Flags().StringArray("ssh-key", []string{}, "SSH public keys in OpenSSH format or as the ID or name of an existing SSH key")
+
+		cmd.Flags().Bool("enable-samba", false, "Whether the Samba subsystem should be enabled")
+		cmd.Flags().Bool("enable-ssh", false, "Whether the SSH subsystem should be enabled")
+		cmd.Flags().Bool("enable-webdav", false, "Whether the WebDAV subsystem should be enabled")
+		cmd.Flags().Bool("enable-zfs", false, "Whether the ZFS Snapshot folder should be visible")
+		cmd.Flags().Bool("reachable-externally", false, "Whether the Storage Box should be accessible from outside the Hetzner network")
+
+		cmd.Flags().StringSlice("enable-protection", []string{}, "Enable protection (delete) (default: none)")
+		_ = cmd.RegisterFlagCompletionFunc("enable-protection", cmpl.SuggestCandidates("delete"))
+
+		return cmd
+	},
+	Run: func(s state.State, cmd *cobra.Command, _ []string) (*hcloud.StorageBox, any, error) {
+		name, _ := cmd.Flags().GetString("name")
+		sbType, _ := cmd.Flags().GetString("type")
+		location, _ := cmd.Flags().GetString("location")
+		password, _ := cmd.Flags().GetString("password")
+		sshKeys, _ := cmd.Flags().GetStringArray("ssh-key")
+		labels, _ := cmd.Flags().GetStringToString("label")
+
+		enableSamba, _ := cmd.Flags().GetBool("enable-samba")
+		enableSSH, _ := cmd.Flags().GetBool("enable-ssh")
+		enableWebDAV, _ := cmd.Flags().GetBool("enable-webdav")
+		enableZFS, _ := cmd.Flags().GetBool("enable-zfs")
+		reachableExternally, _ := cmd.Flags().GetBool("reachable-externally")
+
+		var err error
+		for i, sshKey := range sshKeys {
+			sshKeys[i], err = resolveSSHKey(s, sshKey)
+			if err != nil {
+				return nil, nil, err
+			}
+		}
+
+		opts := hcloud.StorageBoxCreateOpts{
+			Name:           name,
+			StorageBoxType: &hcloud.StorageBoxType{Name: sbType},
+			Location:       &hcloud.Location{Name: location},
+			Labels:         labels,
+			Password:       password,
+			SSHKeys:        sshKeys,
+			AccessSettings: &hcloud.StorageBoxCreateOptsAccessSettings{
+				ReachableExternally: &reachableExternally,
+				SambaEnabled:        &enableSamba,
+				SSHEnabled:          &enableSSH,
+				WebDAVEnabled:       &enableWebDAV,
+				ZFSEnabled:          &enableZFS,
+			},
+		}
+		result, _, err := s.Client().StorageBox().Create(s, opts)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if err := s.WaitForActions(s, cmd, result.Action); err != nil {
+			return nil, nil, err
+		}
+		cmd.Printf("Storage Box %d created\n", result.StorageBox.ID)
+
+		storageBox, _, err := s.Client().StorageBox().GetByID(s, result.StorageBox.ID)
+		if err != nil {
+			return nil, nil, err
+		}
+		if storageBox == nil {
+			return nil, nil, fmt.Errorf("Storage Box not found: %d", result.StorageBox.ID)
+		}
+
+		// TODO change protection here once change-protection is implemented
+
+		return storageBox, util.Wrap("storage_box", hcloud.SchemaFromStorageBox(result.StorageBox)), nil
+	},
+	PrintResource: func(_ state.State, cmd *cobra.Command, storageBox *hcloud.StorageBox) {
+		cmd.Printf("Server: %s\n", *storageBox.Server)
+		cmd.Printf("Username: %s\n", *storageBox.Username)
+	},
+}
+
+// resolveSSHKey resolves the given pubKey by doing the following:
+// - If pubKey is a valid public key in OpenSSH format, it is returned as is.
+// - Otherwise, it is treated as an ID or name of an existing SSH key in the project.
+// - If an SSH key with the given ID or name exists, its public key is returned.
+// - Otherwise, pubKey is returned as is.
+func resolveSSHKey(s state.State, pubKey string) (string, error) {
+	_, _, _, _, err := ssh.ParseAuthorizedKey([]byte(pubKey))
+	if err == nil {
+		return pubKey, nil
+	}
+
+	sshKey, _, err := s.Client().SSHKey().Get(s, pubKey)
+	if err != nil {
+		return "", err
+	}
+	if sshKey != nil {
+		return sshKey.PublicKey, nil
+	}
+
+	return pubKey, nil
+}
diff --git a/internal/cmd/storagebox/create_test.go b/internal/cmd/storagebox/create_test.go
new file mode 100644
index 00000000..cb54acf5
--- /dev/null
+++ b/internal/cmd/storagebox/create_test.go
@@ -0,0 +1,208 @@
+package storagebox_test
+
+import (
+	_ "embed"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+//go:embed testdata/create_response.json
+var createResponseJSON string
+
+const (
+	pubKey1 = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKeCe3ZqukV9WoJdMYlDwpjTvbsWOxiI6V1eWH32gs6F"
+	pubKey2 = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIEx+8JoS7aSSixcqc/muYEeC+6yYeCGO2ip1U33EbDm6"
+)
+
+func TestCreate(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.CreateCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	sb := &hcloud.StorageBox{
+		ID:       123,
+		Name:     "my-storage-box",
+		Server:   hcloud.Ptr("u12345.your-storagebox.de"),
+		Username: hcloud.Ptr("u12345"),
+	}
+
+	fx.Client.SSHKeyClient.EXPECT().
+		Get(gomock.Any(), "mykey").
+		Return(&hcloud.SSHKey{PublicKey: pubKey1}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Create(gomock.Any(), hcloud.StorageBoxCreateOpts{
+			Name:           "my-storage-box",
+			StorageBoxType: &hcloud.StorageBoxType{Name: "bx11"},
+			Location:       &hcloud.Location{Name: "fsn1"},
+			Password:       "my-password",
+			AccessSettings: &hcloud.StorageBoxCreateOptsAccessSettings{
+				SambaEnabled:        hcloud.Ptr(true),
+				SSHEnabled:          hcloud.Ptr(true),
+				ZFSEnabled:          hcloud.Ptr(true),
+				ReachableExternally: hcloud.Ptr(false),
+				WebDAVEnabled:       hcloud.Ptr(false),
+			},
+			Labels:  make(map[string]string),
+			SSHKeys: []string{pubKey1, pubKey2},
+		}).
+		Return(hcloud.StorageBoxCreateResult{
+			StorageBox: sb,
+			Action:     &hcloud.Action{ID: 456},
+		}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		GetByID(gomock.Any(), sb.ID).
+		Return(sb, nil, nil)
+	fx.ActionWaiter.EXPECT().
+		WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 456}).
+		Return(nil)
+
+	out, errOut, err := fx.Run(cmd, []string{"--name", "my-storage-box", "--type", "bx11", "--location", "fsn1",
+		"--password", "my-password", "--enable-samba", "--enable-ssh", "--enable-zfs",
+		"--ssh-key", "mykey", "--ssh-key", pubKey2})
+
+	expOut := `Storage Box 123 created
+Server: u12345.your-storagebox.de
+Username: u12345
+`
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
+
+func TestCreateJSON(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.CreateCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	sb := &hcloud.StorageBox{
+		ID:       42,
+		Username: hcloud.Ptr("u12345"),
+		Status:   hcloud.StorageBoxStatusActive,
+		Name:     "string",
+		StorageBoxType: &hcloud.StorageBoxType{
+			ID:                     42,
+			Name:                   "bx11",
+			Description:            "BX11",
+			SnapshotLimit:          hcloud.Ptr(10),
+			AutomaticSnapshotLimit: hcloud.Ptr(10),
+			SubaccountsLimit:       200,
+			Size:                   1073741824,
+			Pricings: []hcloud.StorageBoxTypeLocationPricing{
+				{
+					Location: "fsn1",
+					PriceHourly: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+					PriceMonthly: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+					SetupFee: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+				},
+			},
+			DeprecatableResource: hcloud.DeprecatableResource{
+				Deprecation: &hcloud.DeprecationInfo{
+					Announced:        time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC),
+					UnavailableAfter: time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+		},
+		Location: &hcloud.Location{
+			ID:          42,
+			Name:        "fsn1",
+			Description: "Falkenstein DC Park 1",
+			Country:     "DE",
+			City:        "Falkenstein",
+			Latitude:    50.47612,
+			Longitude:   12.370071,
+			NetworkZone: "eu-central",
+		},
+		AccessSettings: hcloud.StorageBoxAccessSettings{
+			ReachableExternally: false,
+			SambaEnabled:        false,
+			SSHEnabled:          false,
+			WebDAVEnabled:       false,
+			ZFSEnabled:          false,
+		},
+		Server: hcloud.Ptr("u1337.your-storagebox.de"),
+		System: hcloud.Ptr("FSN1-BX355"),
+		Stats: &hcloud.StorageBoxStats{
+			Size:          0,
+			SizeData:      0,
+			SizeSnapshots: 0,
+		},
+		Labels: map[string]string{
+			"environment":    "prod",
+			"example.com/my": "label",
+			"just-a-key":     "",
+		},
+		Protection: hcloud.StorageBoxProtection{
+			Delete: false,
+		},
+		SnapshotPlan: &hcloud.StorageBoxSnapshotPlan{
+			MaxSnapshots: 0,
+			Minute:       nil,
+			Hour:         nil,
+			DayOfWeek:    nil,
+			DayOfMonth:   nil,
+		},
+		Created: time.Date(2016, 1, 30, 23, 55, 0, 0, time.UTC),
+	}
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Create(gomock.Any(), hcloud.StorageBoxCreateOpts{
+			Name:           "my-storage-box",
+			StorageBoxType: &hcloud.StorageBoxType{Name: "bx11"},
+			Location:       &hcloud.Location{Name: "fsn1"},
+			Password:       "my-password",
+			AccessSettings: &hcloud.StorageBoxCreateOptsAccessSettings{
+				SambaEnabled:        hcloud.Ptr(true),
+				SSHEnabled:          hcloud.Ptr(true),
+				ZFSEnabled:          hcloud.Ptr(true),
+				ReachableExternally: hcloud.Ptr(false),
+				WebDAVEnabled:       hcloud.Ptr(false),
+			},
+			Labels:  make(map[string]string),
+			SSHKeys: []string{pubKey1},
+		}).
+		Return(hcloud.StorageBoxCreateResult{
+			StorageBox: sb,
+			Action:     &hcloud.Action{ID: 456},
+		}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		GetByID(gomock.Any(), sb.ID).
+		Return(sb, nil, nil)
+	fx.ActionWaiter.EXPECT().
+		WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 456}).
+		Return(nil)
+
+	jsonOut, out, err := fx.Run(cmd, []string{"-o=json", "--name", "my-storage-box", "--type", "bx11", "--location", "fsn1",
+		"--password", "my-password", "--enable-samba", "--enable-ssh", "--enable-zfs", "--ssh-key", pubKey1})
+
+	expOut := "Storage Box 42 created\n"
+
+	require.NoError(t, err)
+	assert.Equal(t, expOut, out)
+	assert.JSONEq(t, createResponseJSON, jsonOut)
+}
+
+func TestCreateProtection(_ *testing.T) {
+	// TODO implement once change-protection is implemented
+}
diff --git a/internal/cmd/storagebox/delete.go b/internal/cmd/storagebox/delete.go
new file mode 100644
index 00000000..af7d1831
--- /dev/null
+++ b/internal/cmd/storagebox/delete.go
@@ -0,0 +1,25 @@
+package storagebox
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var DeleteCmd = base.DeleteCmd{
+	ResourceNameSingular: "Storage Box",
+	ResourceNamePlural:   "Storage Boxes",
+	ShortDescription:     "Delete a Storage Box",
+	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.StorageBox().Names },
+	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (any, *hcloud.Response, error) {
+		return s.Client().StorageBox().Get(s, idOrName)
+	},
+	Delete: func(s state.State, _ *cobra.Command, resource any) (*hcloud.Action, error) {
+		storageBox := resource.(*hcloud.StorageBox)
+		action, _, err := s.Client().StorageBox().Delete(s, storageBox)
+		return action, err
+	},
+}
diff --git a/internal/cmd/storagebox/delete_test.go b/internal/cmd/storagebox/delete_test.go
new file mode 100644
index 00000000..af3c8238
--- /dev/null
+++ b/internal/cmd/storagebox/delete_test.go
@@ -0,0 +1,88 @@
+package storagebox_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestDelete(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.DeleteCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	sb := &hcloud.StorageBox{
+		ID:   123,
+		Name: "test",
+	}
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "test").
+		Return(sb, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Delete(gomock.Any(), sb).
+		Return(&hcloud.Action{ID: 456}, nil, nil)
+	fx.ActionWaiter.EXPECT().
+		WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 456}).
+		Return(nil)
+
+	out, errOut, err := fx.Run(cmd, []string{"test"})
+
+	expOut := "Storage Box test deleted\n"
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
+
+func TestDeleteMultiple(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.DeleteCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	storageBoxes := []*hcloud.StorageBox{
+		{
+			ID:   123,
+			Name: "test1",
+		},
+		{
+			ID:   456,
+			Name: "test2",
+		},
+		{
+			ID:   789,
+			Name: "test3",
+		},
+	}
+
+	var names []string
+	for _, sb := range storageBoxes {
+		names = append(names, sb.Name)
+		fx.Client.StorageBoxClient.EXPECT().
+			Get(gomock.Any(), sb.Name).
+			Return(sb, nil, nil)
+		fx.Client.StorageBoxClient.EXPECT().
+			Delete(gomock.Any(), sb).
+			Return(&hcloud.Action{ID: sb.ID + 1000}, nil, nil)
+	}
+
+	fx.ActionWaiter.EXPECT().
+		WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 1123}, &hcloud.Action{ID: 1456}, &hcloud.Action{ID: 1789}).
+		Return(nil)
+
+	out, errOut, err := fx.Run(cmd, names)
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, "Storage Boxes test1, test2, test3 deleted\n", out)
+}
diff --git a/internal/cmd/storagebox/describe.go b/internal/cmd/storagebox/describe.go
new file mode 100644
index 00000000..cecbdf5f
--- /dev/null
+++ b/internal/cmd/storagebox/describe.go
@@ -0,0 +1,120 @@
+package storagebox
+
+import (
+	"strconv"
+
+	"github.com/dustin/go-humanize"
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var DescribeCmd = base.DescribeCmd[*hcloud.StorageBox]{
+	ResourceNameSingular: "Storage Box",
+	ShortDescription:     "Describe a Storage Box",
+	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.StorageBox().Names },
+	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (*hcloud.StorageBox, any, error) {
+		storageBox, _, err := s.Client().StorageBox().Get(s, idOrName)
+		if err != nil {
+			return nil, nil, err
+		}
+		return storageBox, hcloud.SchemaFromStorageBox(storageBox), nil
+	},
+	PrintText: func(_ state.State, cmd *cobra.Command, storageBox *hcloud.StorageBox) error {
+		cmd.Printf("ID:\t\t\t\t%d\n", storageBox.ID)
+		cmd.Printf("Name:\t\t\t\t%s\n", storageBox.Name)
+		cmd.Printf("Created:\t\t\t%s (%s)\n", util.Datetime(storageBox.Created), humanize.Time(storageBox.Created))
+		cmd.Printf("Status:\t\t\t\t%s\n", storageBox.Status)
+		cmd.Printf("Username:\t\t\t%s\n", util.OptionalString(storageBox.Username, "-"))
+		cmd.Printf("Server:\t\t\t\t%s\n", util.OptionalString(storageBox.Server, "-"))
+		cmd.Printf("System:\t\t\t\t%s\n", util.OptionalString(storageBox.System, "-"))
+
+		snapshotPlan := storageBox.SnapshotPlan
+		cmd.Println("Snapshot Plan:")
+		if snapshotPlan == nil {
+			cmd.Println("  No snapshot plan active")
+		} else {
+			cmd.Printf("  Max Snapshots:\t\t%d\n", snapshotPlan.MaxSnapshots)
+			if snapshotPlan.Minute != nil {
+				cmd.Printf("  Minute:\t\t\t%d\n", *snapshotPlan.Minute)
+			}
+			if snapshotPlan.Hour != nil {
+				cmd.Printf("  Hour:\t\t\t\t%d\n", *snapshotPlan.Hour)
+			}
+			if snapshotPlan.DayOfWeek != nil {
+				cmd.Printf("  Day of Week:\t\t\t%s\n", *snapshotPlan.DayOfWeek)
+			}
+			if snapshotPlan.DayOfMonth != nil {
+				cmd.Printf("  Day of Month:\t\t\t%d\n", *snapshotPlan.DayOfMonth)
+			}
+		}
+
+		protection := storageBox.Protection
+		cmd.Println("Protection:")
+		cmd.Printf("  Delete:\t\t\t%t\n", protection.Delete)
+
+		stats := storageBox.Stats
+		cmd.Println("Stats:")
+		if stats == nil {
+			cmd.Println("  No stats available")
+		} else {
+			cmd.Printf("  Size:\t\t\t\t%s\n", humanize.IBytes(stats.Size))
+			cmd.Printf("  Size Data:\t\t\t%s\n", humanize.IBytes(stats.SizeData))
+			cmd.Printf("  Size Snapshots:\t\t%s\n", humanize.IBytes(stats.SizeSnapshots))
+		}
+
+		cmd.Print("Labels:\n")
+		if len(storageBox.Labels) == 0 {
+			cmd.Print("  No labels\n")
+		} else {
+			for key, value := range util.IterateInOrder(storageBox.Labels) {
+				cmd.Printf("  %s: %s\n", key, value)
+			}
+		}
+
+		accessSettings := storageBox.AccessSettings
+		cmd.Println("Access Settings:")
+		cmd.Printf("  Reachable Externally:\t\t%t\n", accessSettings.ReachableExternally)
+		cmd.Printf("  Samba Enabled:\t\t%t\n", accessSettings.SambaEnabled)
+		cmd.Printf("  SSH Enabled:\t\t\t%t\n", accessSettings.SSHEnabled)
+		cmd.Printf("  WebDAV Enabled:\t\t%t\n", accessSettings.WebDAVEnabled)
+		cmd.Printf("  ZFS Enabled:\t\t\t%t\n", accessSettings.ZFSEnabled)
+
+		storageBoxType := storageBox.StorageBoxType
+		cmd.Println("Storage Box Type:")
+		cmd.Printf("  ID:\t\t\t\t%d\n", storageBoxType.ID)
+		cmd.Printf("  Name:\t\t\t\t%s\n", storageBoxType.Name)
+		cmd.Printf("  Description:\t\t\t%s\n", storageBoxType.Description)
+		cmd.Printf("  Size:\t\t\t\t%s\n", humanize.IBytes(uint64(storageBoxType.Size)))
+
+		snapshotLimit := "-"
+		if storageBox.StorageBoxType.SnapshotLimit != nil {
+			snapshotLimit = strconv.Itoa(*storageBox.StorageBoxType.SnapshotLimit)
+		}
+		automaticSnapshotLimit := "-"
+		if storageBox.StorageBoxType.AutomaticSnapshotLimit != nil {
+			automaticSnapshotLimit = strconv.Itoa(*storageBox.StorageBoxType.AutomaticSnapshotLimit)
+		}
+		cmd.Printf("  Snapshot Limit:\t\t%s\n", snapshotLimit)
+		cmd.Printf("  Automatic Snapshot Limit:\t%s\n", automaticSnapshotLimit)
+
+		cmd.Printf("  Subaccounts Limit:\t\t%d\n", storageBoxType.SubaccountsLimit)
+
+		location := storageBox.Location
+		cmd.Println("Location:")
+		cmd.Printf("  ID:\t\t\t\t%d\n", location.ID)
+		cmd.Printf("  Name:\t\t\t\t%s\n", location.Name)
+		cmd.Printf("  Description:\t\t\t%s\n", location.Description)
+		cmd.Printf("  Network Zone:\t\t\t%s\n", location.NetworkZone)
+		cmd.Printf("  Country:\t\t\t%s\n", location.Country)
+		cmd.Printf("  City:\t\t\t\t%s\n", location.City)
+		cmd.Printf("  Latitude:\t\t\t%f\n", location.Latitude)
+		cmd.Printf("  Longitude:\t\t\t%f\n", location.Longitude)
+
+		return nil
+	},
+}
diff --git a/internal/cmd/storagebox/describe_test.go b/internal/cmd/storagebox/describe_test.go
new file mode 100644
index 00000000..7e228251
--- /dev/null
+++ b/internal/cmd/storagebox/describe_test.go
@@ -0,0 +1,163 @@
+package storagebox_test
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestDescribe(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	time.Local = time.UTC
+
+	cmd := storagebox.DescribeCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	storageBox := &hcloud.StorageBox{
+		ID:       123,
+		Username: hcloud.Ptr("u12345"),
+		Status:   hcloud.StorageBoxStatusActive,
+		Name:     "test",
+		StorageBoxType: &hcloud.StorageBoxType{
+			ID:                     42,
+			Name:                   "bx11",
+			Description:            "BX11",
+			SnapshotLimit:          hcloud.Ptr(10),
+			AutomaticSnapshotLimit: hcloud.Ptr(10),
+			SubaccountsLimit:       200,
+			Size:                   1073741824,
+			Pricings: []hcloud.StorageBoxTypeLocationPricing{
+				{
+					Location: "fsn1",
+					PriceHourly: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+					PriceMonthly: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+					SetupFee: hcloud.Price{
+						Net:   "1.0000",
+						Gross: "1.1900",
+					},
+				},
+			},
+			DeprecatableResource: hcloud.DeprecatableResource{
+				Deprecation: &hcloud.DeprecationInfo{
+					UnavailableAfter: time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC),
+					Announced:        time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+		},
+		Location: &hcloud.Location{
+			ID:          42,
+			Name:        "fsn1",
+			Description: "Falkenstein DC Park 1",
+			Country:     "DE",
+			City:        "Falkenstein",
+			Latitude:    50.47612,
+			Longitude:   12.370071,
+			NetworkZone: "eu-central",
+		},
+		AccessSettings: hcloud.StorageBoxAccessSettings{
+			ReachableExternally: false,
+			SambaEnabled:        false,
+			SSHEnabled:          false,
+			WebDAVEnabled:       false,
+			ZFSEnabled:          false,
+		},
+		Server: hcloud.Ptr("u1337.your-storagebox.de"),
+		System: hcloud.Ptr("FSN1-BX355"),
+		Stats: &hcloud.StorageBoxStats{
+			Size:          0,
+			SizeData:      0,
+			SizeSnapshots: 0,
+		},
+		Labels: map[string]string{
+			"environment":    "prod",
+			"example.com/my": "label",
+			"just-a-key":     "",
+		},
+		Protection: hcloud.StorageBoxProtection{
+			Delete: false,
+		},
+		SnapshotPlan: &hcloud.StorageBoxSnapshotPlan{
+			MaxSnapshots: 10,
+			Minute:       hcloud.Ptr(1),
+			Hour:         hcloud.Ptr(2),
+			DayOfWeek:    hcloud.Ptr(time.Sunday),
+			DayOfMonth:   hcloud.Ptr(4),
+		},
+		Created: time.Date(2016, 1, 30, 23, 55, 0, 0, time.UTC),
+	}
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "test").
+		Return(storageBox, nil, nil)
+
+	out, errOut, err := fx.Run(cmd, []string{"test"})
+
+	expOut := fmt.Sprintf(`ID:				123
+Name:				test
+Created:			Sat Jan 30 23:55:00 UTC 2016 (%s)
+Status:				active
+Username:			u12345
+Server:				u1337.your-storagebox.de
+System:				FSN1-BX355
+Snapshot Plan:
+  Max Snapshots:		10
+  Minute:			1
+  Hour:				2
+  Day of Week:			Sunday
+  Day of Month:			4
+Protection:
+  Delete:			false
+Stats:
+  Size:				0 B
+  Size Data:			0 B
+  Size Snapshots:		0 B
+Labels:
+  environment: prod
+  example.com/my: label
+  just-a-key: 
+Access Settings:
+  Reachable Externally:		false
+  Samba Enabled:		false
+  SSH Enabled:			false
+  WebDAV Enabled:		false
+  ZFS Enabled:			false
+Storage Box Type:
+  ID:				42
+  Name:				bx11
+  Description:			BX11
+  Size:				1.0 GiB
+  Snapshot Limit:		10
+  Automatic Snapshot Limit:	10
+  Subaccounts Limit:		200
+Location:
+  ID:				42
+  Name:				fsn1
+  Description:			Falkenstein DC Park 1
+  Network Zone:			eu-central
+  Country:			DE
+  City:				Falkenstein
+  Latitude:			50.476120
+  Longitude:			12.370071
+`, humanize.Time(storageBox.Created))
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
diff --git a/internal/cmd/storagebox/folders.go b/internal/cmd/storagebox/folders.go
new file mode 100644
index 00000000..02d19d56
--- /dev/null
+++ b/internal/cmd/storagebox/folders.go
@@ -0,0 +1,77 @@
+package storagebox
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/cmd/cmpl"
+	"github.com/hetznercloud/cli/internal/cmd/output"
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var FoldersCmd = base.Cmd{
+	BaseCobraCommand: func(client hcapi2.Client) *cobra.Command {
+		cmd := &cobra.Command{
+			Use:                   "folders <storage-box>",
+			Short:                 "List folders of a Storage Box",
+			ValidArgsFunction:     cmpl.SuggestArgs(cmpl.SuggestCandidatesF(client.StorageBox().Names)),
+			TraverseChildren:      true,
+			DisableFlagsInUseLine: true,
+		}
+		cmd.Flags().String("path", "", "Relative path for which the listing is to be made")
+
+		output.AddFlag(cmd, output.OptionJSON(), output.OptionYAML())
+		return cmd
+	},
+	Run: func(s state.State, cmd *cobra.Command, args []string) error {
+		idOrName := args[0]
+		path, _ := cmd.Flags().GetString("path")
+		outOpts := output.FlagsForCommand(cmd)
+
+		storageBox, _, err := s.Client().StorageBox().Get(s, idOrName)
+		if err != nil {
+			return err
+		}
+		if storageBox == nil {
+			return fmt.Errorf("Storage Box not found: %s", idOrName)
+		}
+
+		var opts hcloud.StorageBoxFoldersOpts
+		if cmd.Flags().Changed("path") {
+			opts.Path = path
+		}
+
+		result, _, err := s.Client().StorageBox().Folders(s, storageBox, opts)
+		if err != nil {
+			return err
+		}
+
+		if outOpts.IsSet("json") || outOpts.IsSet("yaml") {
+			schema := struct {
+				Folders []string `json:"folders"`
+			}{
+				Folders: result.Folders,
+			}
+
+			if outOpts.IsSet("json") {
+				return util.DescribeJSON(cmd.OutOrStdout(), schema)
+			}
+			return util.DescribeYAML(cmd.OutOrStdout(), schema)
+		}
+
+		if len(result.Folders) == 0 {
+			cmd.Println("No folders found.")
+		} else {
+			cmd.Println("Folders:")
+			for _, folder := range result.Folders {
+				cmd.Printf("- %s\n", folder)
+			}
+		}
+		return nil
+	},
+}
diff --git a/internal/cmd/storagebox/folders_test.go b/internal/cmd/storagebox/folders_test.go
new file mode 100644
index 00000000..de2cc2c5
--- /dev/null
+++ b/internal/cmd/storagebox/folders_test.go
@@ -0,0 +1,91 @@
+package storagebox_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestFolders(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.FoldersCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "test").
+		Return(&hcloud.StorageBox{ID: 123}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Folders(gomock.Any(), &hcloud.StorageBox{ID: 123}, hcloud.StorageBoxFoldersOpts{Path: ""}).
+		Return(hcloud.StorageBoxFoldersResult{
+			Folders: []string{"folder1", "folder2"},
+		}, nil, nil)
+
+	args := []string{"test"}
+	out, errOut, err := fx.Run(cmd, args)
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, `Folders:
+- folder1
+- folder2
+`, out)
+}
+
+func TestFoldersJSON(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.FoldersCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "test").
+		Return(&hcloud.StorageBox{ID: 123}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Folders(gomock.Any(), &hcloud.StorageBox{ID: 123}, hcloud.StorageBoxFoldersOpts{Path: ""}).
+		Return(hcloud.StorageBoxFoldersResult{
+			Folders: []string{"folder1", "folder2"},
+		}, nil, nil)
+
+	args := []string{"test", "-o=json"}
+	jsonOut, out, err := fx.Run(cmd, args)
+
+	require.NoError(t, err)
+	assert.Empty(t, out)
+	assert.JSONEq(t, `{"folders": ["folder1", "folder2"]}`, jsonOut)
+}
+
+func TestFoldersYAML(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.FoldersCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "test").
+		Return(&hcloud.StorageBox{ID: 123}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Folders(gomock.Any(), &hcloud.StorageBox{ID: 123}, hcloud.StorageBoxFoldersOpts{Path: ""}).
+		Return(hcloud.StorageBoxFoldersResult{
+			Folders: []string{"folder1", "folder2"},
+		}, nil, nil)
+
+	args := []string{"test", "-o=yaml"}
+	yamlOut, out, err := fx.Run(cmd, args)
+
+	require.NoError(t, err)
+	assert.Empty(t, out)
+	assert.YAMLEq(t, `folders:
+- folder1
+- folder2
+`, yamlOut)
+}
diff --git a/internal/cmd/storagebox/labels.go b/internal/cmd/storagebox/labels.go
new file mode 100644
index 00000000..29283a53
--- /dev/null
+++ b/internal/cmd/storagebox/labels.go
@@ -0,0 +1,41 @@
+package storagebox
+
+import (
+	"fmt"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var LabelCmds = base.LabelCmds[*hcloud.StorageBox]{
+	ResourceNameSingular:   "Storage Box",
+	ShortDescriptionAdd:    "Add a label to a Storage Box",
+	ShortDescriptionRemove: "Remove a label from a Storage Box",
+	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.StorageBox().Names },
+	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.StorageBox().LabelKeys },
+	Fetch: func(s state.State, idOrName string) (*hcloud.StorageBox, error) {
+		storageBox, _, err := s.Client().StorageBox().Get(s, idOrName)
+		if err != nil {
+			return nil, err
+		}
+		if storageBox == nil {
+			return nil, fmt.Errorf("Storage Box not found: %s", idOrName)
+		}
+		return storageBox, nil
+	},
+	SetLabels: func(s state.State, storageBox *hcloud.StorageBox, labels map[string]string) error {
+		opts := hcloud.StorageBoxUpdateOpts{
+			Labels: labels,
+		}
+		_, _, err := s.Client().StorageBox().Update(s, storageBox, opts)
+		return err
+	},
+	GetLabels: func(storageBox *hcloud.StorageBox) map[string]string {
+		return storageBox.Labels
+	},
+	GetIDOrName: func(storageBox *hcloud.StorageBox) string {
+		return storageBox.Name
+	},
+}
diff --git a/internal/cmd/storagebox/labels_test.go b/internal/cmd/storagebox/labels_test.go
new file mode 100644
index 00000000..97fdffbf
--- /dev/null
+++ b/internal/cmd/storagebox/labels_test.go
@@ -0,0 +1,76 @@
+package storagebox_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestLabelAdd(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.LabelCmds.AddCobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	sb := &hcloud.StorageBox{
+		ID:   123,
+		Name: "test",
+	}
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "123").
+		Return(sb, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Update(gomock.Any(), sb, hcloud.StorageBoxUpdateOpts{
+			Labels: map[string]string{
+				"key": "value",
+			},
+		})
+
+	out, errOut, err := fx.Run(cmd, []string{"123", "key=value"})
+
+	expOut := "Label(s) key added to Storage Box test\n"
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
+
+func TestLabelRemove(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.LabelCmds.RemoveCobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	sb := &hcloud.StorageBox{
+		ID:   123,
+		Name: "test",
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "123").
+		Return(sb, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Update(gomock.Any(), sb, hcloud.StorageBoxUpdateOpts{
+			Labels: make(map[string]string),
+		})
+
+	out, errOut, err := fx.Run(cmd, []string{"123", "key"})
+
+	expOut := "Label(s) key removed from Storage Box test\n"
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
diff --git a/internal/cmd/storagebox/list.go b/internal/cmd/storagebox/list.go
new file mode 100644
index 00000000..41e2236f
--- /dev/null
+++ b/internal/cmd/storagebox/list.go
@@ -0,0 +1,70 @@
+package storagebox
+
+import (
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"github.com/spf13/pflag"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/cmd/output"
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud/schema"
+)
+
+var ListCmd = base.ListCmd[*hcloud.StorageBox, schema.StorageBox]{
+	ResourceNamePlural: "Storage Boxes",
+	JSONKeyGetByName:   "storage_boxes",
+	DefaultColumns:     []string{"id", "name", "username", "server", "type", "size", "location", "age"},
+	Fetch: func(s state.State, _ *pflag.FlagSet, opts hcloud.ListOpts, _ []string) ([]*hcloud.StorageBox, error) {
+		listOpts := hcloud.StorageBoxListOpts{ListOpts: opts}
+		return s.Client().StorageBox().AllWithOpts(s, listOpts)
+	},
+	OutputTable: func(t *output.Table, _ hcapi2.Client) {
+		t.
+			AddAllowedFields(hcloud.StorageBox{}).
+			AddFieldFn("type", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return storageBox.StorageBoxType.Name
+			}).
+			AddFieldFn("username", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.OptionalString(storageBox.Username, "-")
+			}).
+			AddFieldFn("server", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.OptionalString(storageBox.Server, "-")
+			}).
+			AddFieldFn("system", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.OptionalString(storageBox.System, "-")
+			}).
+			AddFieldFn("location", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return storageBox.Location.Name
+			}).
+			AddFieldFn("size", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				if storageBox.Stats == nil {
+					return "-"
+				}
+				return humanize.IBytes(storageBox.Stats.Size)
+			}).
+			AddFieldFn("labels", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.LabelsToString(storageBox.Labels)
+			}).
+			AddFieldFn("created", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.Datetime(storageBox.Created)
+			}).
+			AddFieldFn("age", func(obj any) string {
+				storageBox := obj.(*hcloud.StorageBox)
+				return util.Age(storageBox.Created, time.Now())
+			})
+	},
+	Schema: hcloud.SchemaFromStorageBox,
+}
diff --git a/internal/cmd/storagebox/list_test.go b/internal/cmd/storagebox/list_test.go
new file mode 100644
index 00000000..d512e4c0
--- /dev/null
+++ b/internal/cmd/storagebox/list_test.go
@@ -0,0 +1,78 @@
+package storagebox_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	require "github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestList(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	time.Local = time.UTC
+
+	cmd := storagebox.ListCmd.CobraCommand(fx.State())
+
+	storageBox := &hcloud.StorageBox{
+		ID:       123,
+		Username: hcloud.Ptr("u12345"),
+		Status:   hcloud.StorageBoxStatusActive,
+		Name:     "test",
+		Location: &hcloud.Location{Name: "fsn1"},
+		Server:   hcloud.Ptr("u1337.your-storagebox.de"),
+		System:   hcloud.Ptr("FSN1-BX355"),
+		StorageBoxType: &hcloud.StorageBoxType{
+			Name: "bx11",
+		},
+		Stats: &hcloud.StorageBoxStats{
+			Size: 42 * util.Gibibyte,
+		},
+		Labels: map[string]string{
+			"environment":    "prod",
+			"example.com/my": "label",
+			"just-a-key":     "",
+		},
+		Protection: hcloud.StorageBoxProtection{
+			Delete: false,
+		},
+		SnapshotPlan: &hcloud.StorageBoxSnapshotPlan{
+			MaxSnapshots: 10,
+			Minute:       hcloud.Ptr(1),
+			Hour:         hcloud.Ptr(2),
+			DayOfWeek:    hcloud.Ptr(time.Sunday),
+			DayOfMonth:   hcloud.Ptr(4),
+		},
+		Created: time.Now().Add(-3 * time.Hour),
+	}
+
+	fx.ExpectEnsureToken()
+	fx.Client.StorageBoxClient.EXPECT().
+		AllWithOpts(
+			gomock.Any(),
+			hcloud.StorageBoxListOpts{
+				ListOpts: hcloud.ListOpts{PerPage: 50},
+			},
+		).
+		Return([]*hcloud.StorageBox{
+			storageBox,
+		}, nil)
+
+	out, errOut, err := fx.Run(cmd, []string{})
+
+	expOut := `ID    NAME   USERNAME   SERVER                     TYPE   SIZE     LOCATION   AGE
+123   test   u12345     u1337.your-storagebox.de   bx11   42 GiB   fsn1       3h 
+`
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
diff --git a/internal/cmd/storagebox/storage_box.go b/internal/cmd/storagebox/storage_box.go
new file mode 100644
index 00000000..12f27469
--- /dev/null
+++ b/internal/cmd/storagebox/storage_box.go
@@ -0,0 +1,30 @@
+package storagebox
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/cli/internal/cmd/util"
+	"github.com/hetznercloud/cli/internal/state"
+)
+
+func NewCommand(s state.State) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                   "storage-box",
+		Aliases:               []string{"storage-boxes"},
+		Short:                 "Manage Storage Boxes",
+		Args:                  util.Validate,
+		TraverseChildren:      true,
+		DisableFlagsInUseLine: true,
+	}
+	cmd.AddCommand(
+		ListCmd.CobraCommand(s),
+		CreateCmd.CobraCommand(s),
+		FoldersCmd.CobraCommand(s),
+		DeleteCmd.CobraCommand(s),
+		DescribeCmd.CobraCommand(s),
+		LabelCmds.AddCobraCommand(s),
+		LabelCmds.RemoveCobraCommand(s),
+		UpdateCmd.CobraCommand(s),
+	)
+	return cmd
+}
diff --git a/internal/cmd/storagebox/testdata/create_response.json b/internal/cmd/storagebox/testdata/create_response.json
new file mode 100644
index 00000000..a93f0e50
--- /dev/null
+++ b/internal/cmd/storagebox/testdata/create_response.json
@@ -0,0 +1,74 @@
+{
+  "storage_box": {
+    "id": 42,
+    "username": "u12345",
+    "status": "active",
+    "name": "string",
+    "storage_box_type": {
+      "id": 42,
+      "name": "bx11",
+      "description": "BX11",
+      "snapshot_limit": 10,
+      "automatic_snapshot_limit": 10,
+      "subaccounts_limit": 200,
+      "size": 1073741824,
+      "prices": [
+        {
+          "location": "fsn1",
+          "price_hourly": {
+            "net": "1.0000",
+            "gross": "1.1900"
+          },
+          "price_monthly": {
+            "net": "1.0000",
+            "gross": "1.1900"
+          },
+          "setup_fee": {
+            "net": "1.0000",
+            "gross": "1.1900"
+          }
+        }
+      ],
+      "deprecation": {
+        "announced": "2023-06-01T00:00:00Z",
+        "unavailable_after": "2023-09-01T00:00:00Z"
+      }
+    },
+    "location": {
+      "id": 42,
+      "name": "fsn1",
+      "description": "Falkenstein DC Park 1",
+      "country": "DE",
+      "city": "Falkenstein",
+      "latitude": 50.47612,
+      "longitude": 12.370071,
+      "network_zone": "eu-central"
+    },
+    "access_settings": {
+      "reachable_externally": false,
+      "samba_enabled": false,
+      "ssh_enabled": false,
+      "webdav_enabled": false,
+      "zfs_enabled": false
+    },
+    "server": "u1337.your-storagebox.de",
+    "system": "FSN1-BX355",
+    "stats": {
+      "size": 0,
+      "size_data": 0,
+      "size_snapshots": 0
+    },
+    "labels": {
+      "environment": "prod",
+      "example.com/my": "label",
+      "just-a-key": ""
+    },
+    "protection": {
+      "delete": false
+    },
+    "snapshot_plan": {
+      "max_snapshots": 0
+    },
+    "created": "2016-01-30T23:55:00Z"
+  }
+}
diff --git a/internal/cmd/storagebox/update.go b/internal/cmd/storagebox/update.go
new file mode 100644
index 00000000..e0e885a2
--- /dev/null
+++ b/internal/cmd/storagebox/update.go
@@ -0,0 +1,34 @@
+package storagebox
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/hetznercloud/cli/internal/cmd/base"
+	"github.com/hetznercloud/cli/internal/hcapi2"
+	"github.com/hetznercloud/cli/internal/state"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+var UpdateCmd = base.UpdateCmd{
+	ResourceNameSingular: "Storage Box",
+	ShortDescription:     "Update a Storage Box",
+	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.StorageBox().Names },
+	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (any, *hcloud.Response, error) {
+		return s.Client().StorageBox().Get(s, idOrName)
+	},
+	DefineFlags: func(cmd *cobra.Command) {
+		cmd.Flags().String("name", "", "Storage Box name")
+	},
+	Update: func(s state.State, _ *cobra.Command, resource interface{}, flags map[string]pflag.Value) error {
+		storageBox := resource.(*hcloud.StorageBox)
+		opts := hcloud.StorageBoxUpdateOpts{
+			Name: flags["name"].String(),
+		}
+		_, _, err := s.Client().StorageBox().Update(s, storageBox, opts)
+		if err != nil {
+			return err
+		}
+		return nil
+	},
+}
diff --git a/internal/cmd/storagebox/update_test.go b/internal/cmd/storagebox/update_test.go
new file mode 100644
index 00000000..49491dfb
--- /dev/null
+++ b/internal/cmd/storagebox/update_test.go
@@ -0,0 +1,37 @@
+package storagebox_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	"github.com/hetznercloud/cli/internal/cmd/storagebox"
+	"github.com/hetznercloud/cli/internal/testutil"
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+func TestUpdateName(t *testing.T) {
+	fx := testutil.NewFixture(t)
+	defer fx.Finish()
+
+	cmd := storagebox.UpdateCmd.CobraCommand(fx.State())
+	fx.ExpectEnsureToken()
+
+	fx.Client.StorageBoxClient.EXPECT().
+		Get(gomock.Any(), "123").
+		Return(&hcloud.StorageBox{ID: 123}, nil, nil)
+	fx.Client.StorageBoxClient.EXPECT().
+		Update(gomock.Any(), &hcloud.StorageBox{ID: 123}, hcloud.StorageBoxUpdateOpts{
+			Name: "new-name",
+		})
+
+	out, errOut, err := fx.Run(cmd, []string{"123", "--name", "new-name"})
+
+	expOut := "Storage Box 123 updated\n"
+
+	require.NoError(t, err)
+	assert.Empty(t, errOut)
+	assert.Equal(t, expOut, out)
+}
diff --git a/internal/cmd/util/util.go b/internal/cmd/util/util.go
index f0cd0379..6402bdb6 100644
--- a/internal/cmd/util/util.go
+++ b/internal/cmd/util/util.go
@@ -399,3 +399,10 @@ func FormatHcloudError(err error) string {
 		return err.Error()
 	}
 }
+
+func OptionalString(s *string, defaultValue string) string {
+	if s == nil || *s == "" {
+		return defaultValue
+	}
+	return *s
+}
diff --git a/internal/hcapi2/client.go b/internal/hcapi2/client.go
index 053987fa..33409200 100644
--- a/internal/hcapi2/client.go
+++ b/internal/hcapi2/client.go
@@ -27,6 +27,7 @@ type Client interface {
 	RDNS() RDNSClient
 	PrimaryIP() PrimaryIPClient
 	Pricing() PricingClient
+	StorageBox() StorageBoxClient
 	StorageBoxType() StorageBoxTypeClient
 	WithOpts(...hcloud.ClientOption)
 }
@@ -51,6 +52,7 @@ type clientCache struct {
 	rdnsClient             RDNSClient
 	primaryIPClient        PrimaryIPClient
 	pricingClient          PricingClient
+	storageBoxClient       StorageBoxClient
 	storageBoxTypeClient   StorageBoxTypeClient
 }
 
@@ -251,6 +253,15 @@ func (c *client) Pricing() PricingClient {
 	return c.cache.pricingClient
 }
 
+func (c *client) StorageBox() StorageBoxClient {
+	c.mu.Lock()
+	if c.cache.storageBoxClient == nil {
+		c.cache.storageBoxClient = NewStorageBoxClient(&c.client.StorageBox)
+	}
+	defer c.mu.Unlock()
+	return c.cache.storageBoxClient
+}
+
 func (c *client) StorageBoxType() StorageBoxTypeClient {
 	c.mu.Lock()
 	if c.cache.storageBoxTypeClient == nil {
diff --git a/internal/hcapi2/mock/client.go b/internal/hcapi2/mock/client.go
index 3742a39a..b65ed037 100644
--- a/internal/hcapi2/mock/client.go
+++ b/internal/hcapi2/mock/client.go
@@ -28,6 +28,7 @@ type Client struct {
 	PlacementGroupClient   *MockPlacementGroupClient
 	RDNSClient             *MockRDNSClient
 	PricingClient          *MockPricingClient
+	StorageBoxClient       *MockStorageBoxClient
 	StorageBoxTypeClient   *MockStorageBoxTypeClient
 }
 
@@ -58,6 +59,7 @@ func NewMockClient(ctrl *gomock.Controller) *Client {
 		PlacementGroupClient:   NewMockPlacementGroupClient(ctrl),
 		RDNSClient:             NewMockRDNSClient(ctrl),
 		PricingClient:          NewMockPricingClient(ctrl),
+		StorageBoxClient:       NewMockStorageBoxClient(ctrl),
 		StorageBoxTypeClient:   NewMockStorageBoxTypeClient(ctrl),
 	}
 }
@@ -137,6 +139,10 @@ func (c *Client) Pricing() hcapi2.PricingClient {
 	return c.PricingClient
 }
 
+func (c *Client) StorageBox() hcapi2.StorageBoxClient {
+	return c.StorageBoxClient
+}
+
 func (c *Client) StorageBoxType() hcapi2.StorageBoxTypeClient {
 	return c.StorageBoxTypeClient
 }
diff --git a/internal/hcapi2/mock/mock_gen.go b/internal/hcapi2/mock/mock_gen.go
index 176fce82..79009e6a 100644
--- a/internal/hcapi2/mock/mock_gen.go
+++ b/internal/hcapi2/mock/mock_gen.go
@@ -19,4 +19,5 @@ package mock
 //go:generate mockgen -package mock -destination zz_placement_group_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 PlacementGroupClient
 //go:generate mockgen -package mock -destination zz_rdns_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 RDNSClient
 //go:generate mockgen -package mock -destination zz_pricing_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 PricingClient
+//go:generate mockgen -package mock -destination zz_storage_box_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 StorageBoxClient
 //go:generate mockgen -package mock -destination zz_storage_box_type_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 StorageBoxTypeClient
diff --git a/internal/hcapi2/mock/zz_storage_box_client_mock.go b/internal/hcapi2/mock/zz_storage_box_client_mock.go
new file mode 100644
index 00000000..7538fc7c
--- /dev/null
+++ b/internal/hcapi2/mock/zz_storage_box_client_mock.go
@@ -0,0 +1,624 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/hetznercloud/cli/internal/hcapi2 (interfaces: StorageBoxClient)
+//
+// Generated by this command:
+//
+//	mockgen -package mock -destination zz_storage_box_client_mock.go github.com/hetznercloud/cli/internal/hcapi2 StorageBoxClient
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	hcloud "github.com/hetznercloud/hcloud-go/v2/hcloud"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStorageBoxClient is a mock of StorageBoxClient interface.
+type MockStorageBoxClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockStorageBoxClientMockRecorder
+	isgomock struct{}
+}
+
+// MockStorageBoxClientMockRecorder is the mock recorder for MockStorageBoxClient.
+type MockStorageBoxClientMockRecorder struct {
+	mock *MockStorageBoxClient
+}
+
+// NewMockStorageBoxClient creates a new mock instance.
+func NewMockStorageBoxClient(ctrl *gomock.Controller) *MockStorageBoxClient {
+	mock := &MockStorageBoxClient{ctrl: ctrl}
+	mock.recorder = &MockStorageBoxClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStorageBoxClient) EXPECT() *MockStorageBoxClientMockRecorder {
+	return m.recorder
+}
+
+// All mocks base method.
+func (m *MockStorageBoxClient) All(ctx context.Context) ([]*hcloud.StorageBox, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "All", ctx)
+	ret0, _ := ret[0].([]*hcloud.StorageBox)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// All indicates an expected call of All.
+func (mr *MockStorageBoxClientMockRecorder) All(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockStorageBoxClient)(nil).All), ctx)
+}
+
+// AllSnapshots mocks base method.
+func (m *MockStorageBoxClient) AllSnapshots(ctx context.Context, storageBox *hcloud.StorageBox) ([]*hcloud.StorageBoxSnapshot, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllSnapshots", ctx, storageBox)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllSnapshots indicates an expected call of AllSnapshots.
+func (mr *MockStorageBoxClientMockRecorder) AllSnapshots(ctx, storageBox any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSnapshots", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSnapshots), ctx, storageBox)
+}
+
+// AllSnapshotsWithOpts mocks base method.
+func (m *MockStorageBoxClient) AllSnapshotsWithOpts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotListOpts) ([]*hcloud.StorageBoxSnapshot, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllSnapshotsWithOpts", ctx, storageBox, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllSnapshotsWithOpts indicates an expected call of AllSnapshotsWithOpts.
+func (mr *MockStorageBoxClientMockRecorder) AllSnapshotsWithOpts(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSnapshotsWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSnapshotsWithOpts), ctx, storageBox, opts)
+}
+
+// AllSubaccounts mocks base method.
+func (m *MockStorageBoxClient) AllSubaccounts(ctx context.Context, storageBox *hcloud.StorageBox) ([]*hcloud.StorageBoxSubaccount, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllSubaccounts", ctx, storageBox)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllSubaccounts indicates an expected call of AllSubaccounts.
+func (mr *MockStorageBoxClientMockRecorder) AllSubaccounts(ctx, storageBox any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSubaccounts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSubaccounts), ctx, storageBox)
+}
+
+// AllSubaccountsWithOpts mocks base method.
+func (m *MockStorageBoxClient) AllSubaccountsWithOpts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountListOpts) ([]*hcloud.StorageBoxSubaccount, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllSubaccountsWithOpts", ctx, storageBox, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllSubaccountsWithOpts indicates an expected call of AllSubaccountsWithOpts.
+func (mr *MockStorageBoxClientMockRecorder) AllSubaccountsWithOpts(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSubaccountsWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSubaccountsWithOpts), ctx, storageBox, opts)
+}
+
+// AllWithOpts mocks base method.
+func (m *MockStorageBoxClient) AllWithOpts(ctx context.Context, opts hcloud.StorageBoxListOpts) ([]*hcloud.StorageBox, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBox)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllWithOpts indicates an expected call of AllWithOpts.
+func (mr *MockStorageBoxClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllWithOpts), ctx, opts)
+}
+
+// ChangeProtection mocks base method.
+func (m *MockStorageBoxClient) ChangeProtection(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangeProtection", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ChangeProtection indicates an expected call of ChangeProtection.
+func (mr *MockStorageBoxClientMockRecorder) ChangeProtection(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockStorageBoxClient)(nil).ChangeProtection), ctx, storageBox, opts)
+}
+
+// ChangeType mocks base method.
+func (m *MockStorageBoxClient) ChangeType(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxChangeTypeOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangeType", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ChangeType indicates an expected call of ChangeType.
+func (mr *MockStorageBoxClientMockRecorder) ChangeType(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeType", reflect.TypeOf((*MockStorageBoxClient)(nil).ChangeType), ctx, storageBox, opts)
+}
+
+// Create mocks base method.
+func (m *MockStorageBoxClient) Create(ctx context.Context, opts hcloud.StorageBoxCreateOpts) (hcloud.StorageBoxCreateResult, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", ctx, opts)
+	ret0, _ := ret[0].(hcloud.StorageBoxCreateResult)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// Create indicates an expected call of Create.
+func (mr *MockStorageBoxClientMockRecorder) Create(ctx, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStorageBoxClient)(nil).Create), ctx, opts)
+}
+
+// CreateSnapshot mocks base method.
+func (m *MockStorageBoxClient) CreateSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotCreateOpts) (hcloud.StorageBoxSnapshotCreateResult, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSnapshot", ctx, storageBox, opts)
+	ret0, _ := ret[0].(hcloud.StorageBoxSnapshotCreateResult)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateSnapshot indicates an expected call of CreateSnapshot.
+func (mr *MockStorageBoxClientMockRecorder) CreateSnapshot(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).CreateSnapshot), ctx, storageBox, opts)
+}
+
+// CreateSubaccount mocks base method.
+func (m *MockStorageBoxClient) CreateSubaccount(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountCreateOpts) (hcloud.StorageBoxSubaccountCreateResult, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSubaccount", ctx, storageBox, opts)
+	ret0, _ := ret[0].(hcloud.StorageBoxSubaccountCreateResult)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateSubaccount indicates an expected call of CreateSubaccount.
+func (mr *MockStorageBoxClientMockRecorder) CreateSubaccount(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).CreateSubaccount), ctx, storageBox, opts)
+}
+
+// Delete mocks base method.
+func (m *MockStorageBoxClient) Delete(ctx context.Context, storageBox *hcloud.StorageBox) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", ctx, storageBox)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// Delete indicates an expected call of Delete.
+func (mr *MockStorageBoxClientMockRecorder) Delete(ctx, storageBox any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStorageBoxClient)(nil).Delete), ctx, storageBox)
+}
+
+// DeleteSnapshot mocks base method.
+func (m *MockStorageBoxClient) DeleteSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, snapshot *hcloud.StorageBoxSnapshot) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSnapshot", ctx, storageBox, snapshot)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// DeleteSnapshot indicates an expected call of DeleteSnapshot.
+func (mr *MockStorageBoxClientMockRecorder) DeleteSnapshot(ctx, storageBox, snapshot any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).DeleteSnapshot), ctx, storageBox, snapshot)
+}
+
+// DeleteSubaccount mocks base method.
+func (m *MockStorageBoxClient) DeleteSubaccount(ctx context.Context, storageBox *hcloud.StorageBox, subaccount *hcloud.StorageBoxSubaccount) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSubaccount", ctx, storageBox, subaccount)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// DeleteSubaccount indicates an expected call of DeleteSubaccount.
+func (mr *MockStorageBoxClientMockRecorder) DeleteSubaccount(ctx, storageBox, subaccount any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).DeleteSubaccount), ctx, storageBox, subaccount)
+}
+
+// DisableSnapshotPlan mocks base method.
+func (m *MockStorageBoxClient) DisableSnapshotPlan(ctx context.Context, storageBox *hcloud.StorageBox) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DisableSnapshotPlan", ctx, storageBox)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// DisableSnapshotPlan indicates an expected call of DisableSnapshotPlan.
+func (mr *MockStorageBoxClientMockRecorder) DisableSnapshotPlan(ctx, storageBox any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotPlan", reflect.TypeOf((*MockStorageBoxClient)(nil).DisableSnapshotPlan), ctx, storageBox)
+}
+
+// EnableSnapshotPlan mocks base method.
+func (m *MockStorageBoxClient) EnableSnapshotPlan(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxEnableSnapshotPlanOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EnableSnapshotPlan", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// EnableSnapshotPlan indicates an expected call of EnableSnapshotPlan.
+func (mr *MockStorageBoxClientMockRecorder) EnableSnapshotPlan(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotPlan", reflect.TypeOf((*MockStorageBoxClient)(nil).EnableSnapshotPlan), ctx, storageBox, opts)
+}
+
+// Folders mocks base method.
+func (m *MockStorageBoxClient) Folders(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxFoldersOpts) (hcloud.StorageBoxFoldersResult, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Folders", ctx, storageBox, opts)
+	ret0, _ := ret[0].(hcloud.StorageBoxFoldersResult)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// Folders indicates an expected call of Folders.
+func (mr *MockStorageBoxClientMockRecorder) Folders(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Folders", reflect.TypeOf((*MockStorageBoxClient)(nil).Folders), ctx, storageBox, opts)
+}
+
+// Get mocks base method.
+func (m *MockStorageBoxClient) Get(ctx context.Context, idOrName string) (*hcloud.StorageBox, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
+	ret0, _ := ret[0].(*hcloud.StorageBox)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockStorageBoxClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStorageBoxClient)(nil).Get), ctx, idOrName)
+}
+
+// GetByID mocks base method.
+func (m *MockStorageBoxClient) GetByID(ctx context.Context, id int64) (*hcloud.StorageBox, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetByID", ctx, id)
+	ret0, _ := ret[0].(*hcloud.StorageBox)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetByID indicates an expected call of GetByID.
+func (mr *MockStorageBoxClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetByID), ctx, id)
+}
+
+// GetByName mocks base method.
+func (m *MockStorageBoxClient) GetByName(ctx context.Context, name string) (*hcloud.StorageBox, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetByName", ctx, name)
+	ret0, _ := ret[0].(*hcloud.StorageBox)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetByName indicates an expected call of GetByName.
+func (mr *MockStorageBoxClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockStorageBoxClient)(nil).GetByName), ctx, name)
+}
+
+// GetSnapshot mocks base method.
+func (m *MockStorageBoxClient) GetSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, idOrName string) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshot", ctx, storageBox, idOrName)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetSnapshot indicates an expected call of GetSnapshot.
+func (mr *MockStorageBoxClientMockRecorder) GetSnapshot(ctx, storageBox, idOrName any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshot), ctx, storageBox, idOrName)
+}
+
+// GetSnapshotByID mocks base method.
+func (m *MockStorageBoxClient) GetSnapshotByID(ctx context.Context, storageBox *hcloud.StorageBox, id int64) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotByID", ctx, storageBox, id)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetSnapshotByID indicates an expected call of GetSnapshotByID.
+func (mr *MockStorageBoxClientMockRecorder) GetSnapshotByID(ctx, storageBox, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshotByID), ctx, storageBox, id)
+}
+
+// GetSnapshotByName mocks base method.
+func (m *MockStorageBoxClient) GetSnapshotByName(ctx context.Context, storageBox *hcloud.StorageBox, name string) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotByName", ctx, storageBox, name)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetSnapshotByName indicates an expected call of GetSnapshotByName.
+func (mr *MockStorageBoxClientMockRecorder) GetSnapshotByName(ctx, storageBox, name any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByName", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshotByName), ctx, storageBox, name)
+}
+
+// GetSubaccountByID mocks base method.
+func (m *MockStorageBoxClient) GetSubaccountByID(ctx context.Context, storageBox *hcloud.StorageBox, id int64) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSubaccountByID", ctx, storageBox, id)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetSubaccountByID indicates an expected call of GetSubaccountByID.
+func (mr *MockStorageBoxClientMockRecorder) GetSubaccountByID(ctx, storageBox, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubaccountByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSubaccountByID), ctx, storageBox, id)
+}
+
+// LabelKeys mocks base method.
+func (m *MockStorageBoxClient) LabelKeys(arg0 string) []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LabelKeys", arg0)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// LabelKeys indicates an expected call of LabelKeys.
+func (mr *MockStorageBoxClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockStorageBoxClient)(nil).LabelKeys), arg0)
+}
+
+// List mocks base method.
+func (m *MockStorageBoxClient) List(ctx context.Context, opts hcloud.StorageBoxListOpts) ([]*hcloud.StorageBox, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", ctx, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBox)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// List indicates an expected call of List.
+func (mr *MockStorageBoxClientMockRecorder) List(ctx, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStorageBoxClient)(nil).List), ctx, opts)
+}
+
+// ListSnapshots mocks base method.
+func (m *MockStorageBoxClient) ListSnapshots(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotListOpts) ([]*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListSnapshots", ctx, storageBox, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListSnapshots indicates an expected call of ListSnapshots.
+func (mr *MockStorageBoxClientMockRecorder) ListSnapshots(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockStorageBoxClient)(nil).ListSnapshots), ctx, storageBox, opts)
+}
+
+// ListSubaccounts mocks base method.
+func (m *MockStorageBoxClient) ListSubaccounts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountListOpts) ([]*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListSubaccounts", ctx, storageBox, opts)
+	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListSubaccounts indicates an expected call of ListSubaccounts.
+func (mr *MockStorageBoxClientMockRecorder) ListSubaccounts(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubaccounts", reflect.TypeOf((*MockStorageBoxClient)(nil).ListSubaccounts), ctx, storageBox, opts)
+}
+
+// Names mocks base method.
+func (m *MockStorageBoxClient) Names() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Names")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// Names indicates an expected call of Names.
+func (mr *MockStorageBoxClientMockRecorder) Names() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockStorageBoxClient)(nil).Names))
+}
+
+// ResetPassword mocks base method.
+func (m *MockStorageBoxClient) ResetPassword(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxResetPasswordOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResetPassword", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ResetPassword indicates an expected call of ResetPassword.
+func (mr *MockStorageBoxClientMockRecorder) ResetPassword(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPassword", reflect.TypeOf((*MockStorageBoxClient)(nil).ResetPassword), ctx, storageBox, opts)
+}
+
+// ResetSubaccountPassword mocks base method.
+func (m *MockStorageBoxClient) ResetSubaccountPassword(ctx context.Context, storageBox *hcloud.StorageBox, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountResetPasswordOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResetSubaccountPassword", ctx, storageBox, subaccount, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ResetSubaccountPassword indicates an expected call of ResetSubaccountPassword.
+func (mr *MockStorageBoxClientMockRecorder) ResetSubaccountPassword(ctx, storageBox, subaccount, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSubaccountPassword", reflect.TypeOf((*MockStorageBoxClient)(nil).ResetSubaccountPassword), ctx, storageBox, subaccount, opts)
+}
+
+// RollbackSnapshot mocks base method.
+func (m *MockStorageBoxClient) RollbackSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxRollbackSnapshotOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RollbackSnapshot", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// RollbackSnapshot indicates an expected call of RollbackSnapshot.
+func (mr *MockStorageBoxClientMockRecorder) RollbackSnapshot(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).RollbackSnapshot), ctx, storageBox, opts)
+}
+
+// Update mocks base method.
+func (m *MockStorageBoxClient) Update(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxUpdateOpts) (*hcloud.StorageBox, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.StorageBox)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// Update indicates an expected call of Update.
+func (mr *MockStorageBoxClientMockRecorder) Update(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStorageBoxClient)(nil).Update), ctx, storageBox, opts)
+}
+
+// UpdateAccessSettings mocks base method.
+func (m *MockStorageBoxClient) UpdateAccessSettings(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxUpdateAccessSettingsOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateAccessSettings", ctx, storageBox, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateAccessSettings indicates an expected call of UpdateAccessSettings.
+func (mr *MockStorageBoxClientMockRecorder) UpdateAccessSettings(ctx, storageBox, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccessSettings", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateAccessSettings), ctx, storageBox, opts)
+}
+
+// UpdateSnapshot mocks base method.
+func (m *MockStorageBoxClient) UpdateSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, snapshot *hcloud.StorageBoxSnapshot, opts hcloud.StorageBoxSnapshotUpdateOpts) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSnapshot", ctx, storageBox, snapshot, opts)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateSnapshot indicates an expected call of UpdateSnapshot.
+func (mr *MockStorageBoxClientMockRecorder) UpdateSnapshot(ctx, storageBox, snapshot, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSnapshot), ctx, storageBox, snapshot, opts)
+}
+
+// UpdateSubaccount mocks base method.
+func (m *MockStorageBoxClient) UpdateSubaccount(ctx context.Context, storageBox *hcloud.StorageBox, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountUpdateOpts) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSubaccount", ctx, storageBox, subaccount, opts)
+	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateSubaccount indicates an expected call of UpdateSubaccount.
+func (mr *MockStorageBoxClientMockRecorder) UpdateSubaccount(ctx, storageBox, subaccount, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSubaccount), ctx, storageBox, subaccount, opts)
+}
+
+// UpdateSubaccountAccessSettings mocks base method.
+func (m *MockStorageBoxClient) UpdateSubaccountAccessSettings(ctx context.Context, storageBox *hcloud.StorageBox, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountAccessSettingsUpdateOpts) (*hcloud.Action, *hcloud.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSubaccountAccessSettings", ctx, storageBox, subaccount, opts)
+	ret0, _ := ret[0].(*hcloud.Action)
+	ret1, _ := ret[1].(*hcloud.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateSubaccountAccessSettings indicates an expected call of UpdateSubaccountAccessSettings.
+func (mr *MockStorageBoxClientMockRecorder) UpdateSubaccountAccessSettings(ctx, storageBox, subaccount, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubaccountAccessSettings", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSubaccountAccessSettings), ctx, storageBox, subaccount, opts)
+}
diff --git a/internal/hcapi2/storage_box.go b/internal/hcapi2/storage_box.go
new file mode 100644
index 00000000..dce1f6b5
--- /dev/null
+++ b/internal/hcapi2/storage_box.go
@@ -0,0 +1,52 @@
+package hcapi2
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+)
+
+type StorageBoxClient interface {
+	hcloud.IStorageBoxClient
+	Names() []string
+	LabelKeys(string) []string
+}
+
+func NewStorageBoxClient(client hcloud.IStorageBoxClient) StorageBoxClient {
+	return &storageBoxClient{
+		IStorageBoxClient: client,
+	}
+}
+
+type storageBoxClient struct {
+	hcloud.IStorageBoxClient
+}
+
+// Names obtains a list of available Storage Boxes. It returns nil if Storage Box
+// names could not be fetched or none are available.
+func (c *storageBoxClient) Names() []string {
+	storageBoxes, err := c.All(context.Background())
+	if err != nil || len(storageBoxes) == 0 {
+		return nil
+	}
+	names := make([]string, len(storageBoxes))
+	for i, storageBox := range storageBoxes {
+		name := storageBox.Name
+		if name == "" {
+			name = strconv.FormatInt(storageBox.ID, 10)
+		}
+		names[i] = name
+	}
+	return names
+}
+
+// LabelKeys returns a slice containing the keys of all labels assigned to
+// the Storage Box with the passed name or id.
+func (c *storageBoxClient) LabelKeys(nameOrID string) []string {
+	storageBox, _, err := c.Get(context.Background(), nameOrID)
+	if err != nil || storageBox == nil || len(storageBox.Labels) == 0 {
+		return nil
+	}
+	return labelKeys(storageBox.Labels)
+}