diff --git a/internal/domain/ennoblement.go b/internal/domain/ennoblement.go
index e039309..1ee2a6d 100644
--- a/internal/domain/ennoblement.go
+++ b/internal/domain/ennoblement.go
@@ -222,7 +222,19 @@ func (params *ListEnnoblementsParams) ServerKeys() []string {
 }
 
 func (params *ListEnnoblementsParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listEnnoblementsParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/ennoblement_test.go b/internal/domain/ennoblement_test.go
index c79bc68..6e0329a 100644
--- a/internal/domain/ennoblement_test.go
+++ b/internal/domain/ennoblement_test.go
@@ -102,6 +102,60 @@ func TestEnnoblementSort_IsInConflict(t *testing.T) {
 	}
 }
 
+func TestListEnnoblementsParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListEnnoblementsParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListEnnoblementsParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListEnnoblementsParams_SetSort(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/domain/player.go b/internal/domain/player.go
index db00f1d..24eea00 100644
--- a/internal/domain/player.go
+++ b/internal/domain/player.go
@@ -716,7 +716,19 @@ func (params *ListPlayersParams) ServerKeys() []string {
 }
 
 func (params *ListPlayersParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listPlayersParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/player_snapshot.go b/internal/domain/player_snapshot.go
index 14a7df6..fca947a 100644
--- a/internal/domain/player_snapshot.go
+++ b/internal/domain/player_snapshot.go
@@ -255,7 +255,19 @@ func (params *ListPlayerSnapshotsParams) ServerKeys() []string {
 }
 
 func (params *ListPlayerSnapshotsParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listPlayerSnapshotsParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/player_snapshot_test.go b/internal/domain/player_snapshot_test.go
index df0c8c2..31d601c 100644
--- a/internal/domain/player_snapshot_test.go
+++ b/internal/domain/player_snapshot_test.go
@@ -109,6 +109,60 @@ func TestPlayerSnapshotSort_IsInConflict(t *testing.T) {
 	}
 }
 
+func TestListPlayerSnapshotsParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListPlayerSnapshotsParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListPlayerSnapshotsParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListPlayerSnapshotsParams_SetSort(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/domain/player_test.go b/internal/domain/player_test.go
index 89602c9..841a920 100644
--- a/internal/domain/player_test.go
+++ b/internal/domain/player_test.go
@@ -567,6 +567,60 @@ func TestListPlayersParams_SetIDs(t *testing.T) {
 	}
 }
 
+func TestListPlayersParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListPlayersParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListPlayersParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListPlayersParams_SetNames(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/domain/tribe_change.go b/internal/domain/tribe_change.go
index 4cace66..e156438 100644
--- a/internal/domain/tribe_change.go
+++ b/internal/domain/tribe_change.go
@@ -269,7 +269,19 @@ func (params *ListTribeChangesParams) ServerKeys() []string {
 }
 
 func (params *ListTribeChangesParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listTribeChangesParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/tribe_change_test.go b/internal/domain/tribe_change_test.go
index 5796df9..b0a2f11 100644
--- a/internal/domain/tribe_change_test.go
+++ b/internal/domain/tribe_change_test.go
@@ -279,6 +279,60 @@ func TestTribeChangeSort_IsInConflict(t *testing.T) {
 	}
 }
 
+func TestListTribeChangesParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListTribeChangesParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListTribeChangesParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListTribeChangesParams_SetSort(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/domain/tribe_snapshot.go b/internal/domain/tribe_snapshot.go
index e1a1563..0857534 100644
--- a/internal/domain/tribe_snapshot.go
+++ b/internal/domain/tribe_snapshot.go
@@ -282,7 +282,19 @@ func (params *ListTribeSnapshotsParams) ServerKeys() []string {
 }
 
 func (params *ListTribeSnapshotsParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listTribeSnapshotsParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/tribe_snapshot_test.go b/internal/domain/tribe_snapshot_test.go
index f3dc06c..f34ed38 100644
--- a/internal/domain/tribe_snapshot_test.go
+++ b/internal/domain/tribe_snapshot_test.go
@@ -111,6 +111,60 @@ func TestTribeSnapshotSort_IsInConflict(t *testing.T) {
 	}
 }
 
+func TestListTribeSnapshotsParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListTribeSnapshotsParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListTribeSnapshotsParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListTribeSnapshotsParams_SetSort(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/domain/village.go b/internal/domain/village.go
index 2020220..893ecb5 100644
--- a/internal/domain/village.go
+++ b/internal/domain/village.go
@@ -318,7 +318,19 @@ func (params *ListVillagesParams) ServerKeys() []string {
 }
 
 func (params *ListVillagesParams) SetServerKeys(serverKeys []string) error {
+	for i, sk := range serverKeys {
+		if err := validateServerKey(sk); err != nil {
+			return SliceElementValidationError{
+				Model: listVillagesParamsModelName,
+				Field: "serverKeys",
+				Index: i,
+				Err:   err,
+			}
+		}
+	}
+
 	params.serverKeys = serverKeys
+
 	return nil
 }
 
diff --git a/internal/domain/village_test.go b/internal/domain/village_test.go
index 108fbac..d797722 100644
--- a/internal/domain/village_test.go
+++ b/internal/domain/village_test.go
@@ -261,6 +261,60 @@ func TestListVillagesParams_SetIDGT(t *testing.T) {
 	}
 }
 
+func TestListVillagesParams_SetServerKeys(t *testing.T) {
+	t.Parallel()
+
+	type args struct {
+		serverKeys []string
+	}
+
+	type test struct {
+		name        string
+		args        args
+		expectedErr error
+	}
+
+	tests := []test{
+		{
+			name: "OK",
+			args: args{
+				serverKeys: []string{
+					domaintest.RandServerKey(),
+				},
+			},
+		},
+	}
+
+	for _, serverKeyTest := range newServerKeyValidationTests() {
+		tests = append(tests, test{
+			name: serverKeyTest.name,
+			args: args{
+				serverKeys: []string{serverKeyTest.key},
+			},
+			expectedErr: domain.SliceElementValidationError{
+				Model: "ListVillagesParams",
+				Field: "serverKeys",
+				Index: 0,
+				Err:   serverKeyTest.expectedErr,
+			},
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			params := domain.NewListVillagesParams()
+
+			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
+			if tt.expectedErr != nil {
+				return
+			}
+			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
+		})
+	}
+}
+
 func TestListVillagesParams_SetSort(t *testing.T) {
 	t.Parallel()