diff --git a/internal/cmd/base/labels.go b/internal/cmd/base/labels.go
index cee35c18..be4acc9a 100644
--- a/internal/cmd/base/labels.go
+++ b/internal/cmd/base/labels.go
@@ -4,8 +4,10 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"maps"
 	"slices"
 	"strings"
+	"sync"
 
 	"github.com/spf13/cobra"
 
@@ -15,6 +17,20 @@ import (
 	"github.com/hetznercloud/cli/internal/state"
 )
 
+// labelBatchSize is the batch size when processing multiple resources in parallel.
+const labelBatchSize = 10
+
+// BatchLabelResult represents the result of a batch label operation for a single resource.
+type BatchLabelResult struct {
+	IDOrName      string
+	Resource      interface{}
+	Success       bool
+	Error         error
+	LabelsAdded   []string
+	LabelsRemoved []string
+	AllLabelsRemoved bool
+}
+
 // LabelCmds allows defining commands for adding labels to resources.
 type LabelCmds[T any] struct {
 	ResourceNameSingular   string
@@ -48,6 +64,10 @@ type LabelCmds[T any] struct {
 
 	// Experimental is a function that will be used to mark the command as experimental.
 	Experimental func(state.State, *cobra.Command) *cobra.Command
+
+	// Batch operation support
+	FetchBatch    func(s state.State, idOrNames []string) ([]T, []error)
+	SetLabelsBatch func(s state.State, resources []T, labels map[string]string) []error
 }
 
 // AddCobraCommand creates a command that can be registered with cobra.
@@ -65,15 +85,15 @@ func (lc *LabelCmds[T]) AddCobraCommand(s state.State) *cobra.Command {
 	}
 
 	cmd := &cobra.Command{
-		Use:                   fmt.Sprintf("add-label [--overwrite] %s <label>...", positionalArguments(lc.ResourceNameSingular, lc.PositionalArgumentOverride)),
+		Use:                   fmt.Sprintf("add-label [--overwrite] %s... <label>...", positionalArguments(lc.ResourceNameSingular, lc.PositionalArgumentOverride)),
 		Short:                 lc.ShortDescriptionAdd,
 		Args:                  util.Validate,
 		ValidArgsFunction:     cmpl.SuggestArgs(suggestArgs...),
 		TraverseChildren:      true,
 		DisableFlagsInUseLine: true,
-		PreRunE:               util.ChainRunE(lc.validateAddLabel, s.EnsureToken),
+		PreRunE:               util.ChainRunE(lc.validateAddLabelBatch, s.EnsureToken),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return lc.RunAdd(s, cmd, args)
+			return lc.RunAddBatch(s, cmd, args)
 		},
 	}
 
@@ -130,6 +150,170 @@ func (lc *LabelCmds[T]) RunAdd(s state.State, cmd *cobra.Command, args []string)
 	return nil
 }
 
+// RunAddBatch executes a batch add label command
+func (lc *LabelCmds[T]) RunAddBatch(s state.State, cmd *cobra.Command, args []string) error {
+	overwrite, _ := cmd.Flags().GetBool("overwrite")
+
+	// Parse arguments to separate resources from labels
+	var resourceArgs []string
+	var labelArgs []string
+
+	// Separate arguments: those with '=' are labels, others are resources
+	for _, arg := range args {
+		if strings.Contains(arg, "=") {
+			labelArgs = append(labelArgs, arg)
+		} else {
+			resourceArgs = append(resourceArgs, arg)
+		}
+	}
+
+	if len(resourceArgs) == 0 {
+		return fmt.Errorf("must specify at least one %s", strings.ToLower(lc.ResourceNameSingular))
+	}
+
+	if len(labelArgs) == 0 {
+		return fmt.Errorf("must specify at least one label")
+	}
+
+	// Parse labels to add
+	labelsToAdd := make(map[string]string)
+	var labelKeys []string
+	for _, label := range labelArgs {
+		key, val := util.SplitLabelVars(label)
+		labelsToAdd[key] = val
+		labelKeys = append(labelKeys, key)
+	}
+
+	// Process resources in batches
+	errs := make([]error, 0, len(resourceArgs))
+	results := make([]BatchLabelResult, 0, len(resourceArgs))
+
+	for batch := range slices.Chunk(resourceArgs, labelBatchSize) {
+		batchResults := lc.processAddBatch(s, batch, labelsToAdd, overwrite)
+		results = append(results, batchResults...)
+
+		// Collect errors
+		for _, result := range batchResults {
+			if result.Error != nil {
+				errs = append(errs, result.Error)
+			}
+		}
+	}
+
+	// Display results
+	lc.displayAddResults(cmd, results, labelKeys)
+
+	return errors.Join(errs...)
+}
+
+// processAddBatch processes a batch of resources for adding labels
+func (lc *LabelCmds[T]) processAddBatch(s state.State, idOrNames []string, labelsToAdd map[string]string, overwrite bool) []BatchLabelResult {
+	results := make([]BatchLabelResult, len(idOrNames))
+
+	// Fetch all resources in batch
+	resources, fetchErrors := lc.fetchResourcesBatch(s, idOrNames)
+
+	for i, idOrName := range idOrNames {
+		results[i] = BatchLabelResult{IDOrName: idOrName}
+
+		if fetchErrors[i] != nil {
+			results[i].Error = fetchErrors[i]
+			continue
+		}
+
+		resource := resources[i]
+		if util.IsNil(resource) {
+			results[i].Error = fmt.Errorf("%s not found: %s", lc.ResourceNameSingular, idOrName)
+			continue
+		}
+
+		// Get current labels
+		existingLabels := lc.GetLabels(resource)
+		if existingLabels == nil {
+			existingLabels = make(map[string]string)
+		}
+
+		// Check for conflicts
+		var conflictKeys []string
+		for key := range labelsToAdd {
+			if _, exists := existingLabels[key]; exists && !overwrite {
+				conflictKeys = append(conflictKeys, key)
+			}
+		}
+
+		if len(conflictKeys) > 0 {
+			results[i].Error = fmt.Errorf("label(s) %s on %s %s already exist",
+				strings.Join(conflictKeys, ", "), lc.ResourceNameSingular, idOrName)
+			continue
+		}
+
+		// Merge new labels
+		for key, value := range labelsToAdd {
+			existingLabels[key] = value
+		}
+
+		// Apply labels
+		if err := lc.SetLabels(s, resource, existingLabels); err != nil {
+			results[i].Error = err
+			continue
+		}
+
+		results[i].Success = true
+		results[i].Resource = resource
+		results[i].LabelsAdded = slices.Collect(maps.Keys(labelsToAdd))
+	}
+
+	return results
+}
+
+// fetchResourcesBatch fetches multiple resources in parallel
+func (lc *LabelCmds[T]) fetchResourcesBatch(s state.State, idOrNames []string) ([]T, []error) {
+	if lc.FetchBatch != nil {
+		return lc.FetchBatch(s, idOrNames)
+	}
+
+	// Fallback to individual fetching with goroutines
+	resources := make([]T, len(idOrNames))
+	errors := make([]error, len(idOrNames))
+
+	var wg sync.WaitGroup
+	for i, idOrName := range idOrNames {
+		wg.Add(1)
+		go func(idx int, id string) {
+			defer wg.Done()
+			resource, err := lc.Fetch(s, id)
+			resources[idx] = resource
+			errors[idx] = err
+		}(i, idOrName)
+	}
+	wg.Wait()
+
+	return resources, errors
+}
+
+// displayAddResults displays the results of a batch add operation
+func (lc *LabelCmds[T]) displayAddResults(cmd *cobra.Command, results []BatchLabelResult, labelKeys []string) {
+	successful := 0
+	failed := 0
+
+	for _, result := range results {
+		if result.Success {
+			successful++
+			cmd.Printf("✓ %s: Labels %s added\n",
+				result.IDOrName,
+				strings.Join(labelKeys, ", "))
+		} else {
+			failed++
+			cmd.Printf("✗ %s: %v\n", result.IDOrName, result.Error)
+		}
+	}
+
+	// Summary for multiple resources
+	if len(results) > 1 {
+		cmd.Printf("\nSummary: %d successful, %d failed\n", successful, failed)
+	}
+}
+
 func (lc *LabelCmds[T]) validateAddLabel(_ *cobra.Command, args []string) error {
 	numPosArgs := max(1, len(lc.PositionalArgumentOverride))
 
@@ -142,6 +326,38 @@ func (lc *LabelCmds[T]) validateAddLabel(_ *cobra.Command, args []string) error
 	return nil
 }
 
+// validateAddLabelBatch validates arguments for batch add label operations
+func (lc *LabelCmds[T]) validateAddLabelBatch(_ *cobra.Command, args []string) error {
+	var resourceArgs []string
+	var labelArgs []string
+
+	// Separate arguments: those with '=' are labels, others are resources
+	for _, arg := range args {
+		if strings.Contains(arg, "=") {
+			labelArgs = append(labelArgs, arg)
+		} else {
+			resourceArgs = append(resourceArgs, arg)
+		}
+	}
+
+	if len(resourceArgs) == 0 {
+		return fmt.Errorf("must specify at least one %s", strings.ToLower(lc.ResourceNameSingular))
+	}
+
+	if len(labelArgs) == 0 {
+		return fmt.Errorf("must specify at least one label")
+	}
+
+	// Validate label format for all labels
+	for _, label := range labelArgs {
+		if len(util.SplitLabel(label)) != 2 {
+			return fmt.Errorf("invalid label: %s", label)
+		}
+	}
+
+	return nil
+}
+
 // RemoveCobraCommand creates a command that can be registered with cobra.
 func (lc *LabelCmds[T]) RemoveCobraCommand(s state.State) *cobra.Command {
 	var suggestArgs []cobra.CompletionFunc
diff --git a/internal/cmd/base/labels_test.go b/internal/cmd/base/labels_test.go
new file mode 100644
index 00000000..f460da2b
--- /dev/null
+++ b/internal/cmd/base/labels_test.go
@@ -0,0 +1,466 @@
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+
+	"github.com/hetznercloud/cli/internal/state"
+)
+
+// MockResource represents a mock resource for testing
+type MockResource struct {
+	ID     int64
+	Name   string
+	Labels map[string]string
+}
+
+// MockLabelCmds creates a mock LabelCmds for testing
+func createMockLabelCmds() *LabelCmds[*MockResource] {
+	return &LabelCmds[*MockResource]{
+		ResourceNameSingular: "Mock Resource",
+		ShortDescriptionAdd:  "Add a label to a Mock Resource",
+		Fetch: func(s state.State, idOrName string) (*MockResource, error) {
+			// Mock implementation - return a resource if name starts with "mock"
+			if strings.HasPrefix(idOrName, "mock") {
+				return &MockResource{
+					ID:     1,
+					Name:   idOrName,
+					Labels: make(map[string]string),
+				}, nil
+			}
+			return nil, &hcloud.Error{Code: hcloud.ErrorCodeNotFound}
+		},
+		SetLabels: func(s state.State, resource *MockResource, labels map[string]string) error {
+			resource.Labels = labels
+			return nil
+		},
+		GetLabels: func(resource *MockResource) map[string]string {
+			return resource.Labels
+		},
+		GetIDOrName: func(resource *MockResource) string {
+			return resource.Name
+		},
+		FetchBatch: func(s state.State, idOrNames []string) ([]*MockResource, []error) {
+			resources := make([]*MockResource, len(idOrNames))
+			errors := make([]error, len(idOrNames))
+
+			for i, idOrName := range idOrNames {
+				if strings.HasPrefix(idOrName, "mock") {
+					resources[i] = &MockResource{
+						ID:     int64(i + 1),
+						Name:   idOrName,
+						Labels: make(map[string]string),
+					}
+				} else {
+					errors[i] = &hcloud.Error{Code: hcloud.ErrorCodeNotFound}
+				}
+			}
+
+			return resources, errors
+		},
+		SetLabelsBatch: func(s state.State, resources []*MockResource, labels map[string]string) []error {
+			errors := make([]error, len(resources))
+			for _, resource := range resources {
+				if resource != nil {
+					resource.Labels = labels
+				}
+			}
+			return errors
+		},
+	}
+}
+
+func TestLabelCmds_RunAddBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	// Mock state (we won't use it in this test)
+	var mockState state.State
+
+	// Mock command
+	cmd := &cobra.Command{}
+
+	// Test successful batch operation
+	args := []string{"mock1", "mock2", "env=prod", "team=backend"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	// Should not return an error for successful operations
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_PartialFailure(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	// Mock state
+	var mockState state.State
+
+	// Mock command
+	cmd := &cobra.Command{}
+
+	// Test partial failure (some resources exist, some don't)
+	args := []string{"mock1", "nonexistent", "mock2", "env=prod"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	// Should return an error due to partial failure
+	if err == nil {
+		t.Error("Expected error due to partial failure, got nil")
+	}
+
+	// Check that error contains information about failures
+	if !strings.Contains(err.Error(), "not_found") {
+		t.Errorf("Expected error to contain 'not_found', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_NoResources(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with no resources
+	args := []string{"env=prod"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for no resources, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one") {
+		t.Errorf("Expected error to contain 'must specify at least one', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_NoLabels(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with no labels
+	args := []string{"mock1", "mock2"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for no labels, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_InvalidLabelFormat(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with invalid label format
+	args := []string{"mock1", "invalid-label"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for invalid label format, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "mock2", "env=prod", "team=backend"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err != nil {
+		t.Errorf("Expected no validation error, got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_NoResources(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"env=prod", "team=backend"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for no resources, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one mock resource") {
+		t.Errorf("Expected error to contain 'must specify at least one mock resource', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_NoLabels(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "mock2"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for no labels, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_InvalidLabel(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "invalid-label-format"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for invalid label, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_MixedOrder(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	// Test mixed order of resources and labels
+	args := []string{"env=prod", "mock1", "team=backend", "mock2"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err != nil {
+		t.Errorf("Expected no validation error for mixed order, got: %v", err)
+	}
+}
+
+func TestLabelCmds_processAddBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "mock2"}
+	labelsToAdd := map[string]string{
+		"env":  "prod",
+		"team": "backend",
+	}
+
+	results := cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+
+	if len(results) != 2 {
+		t.Errorf("Expected 2 results, got %d", len(results))
+	}
+
+	for i, result := range results {
+		if !result.Success {
+			t.Errorf("Expected result %d to be successful, got error: %v", i, result.Error)
+		}
+		if result.IDOrName != idOrNames[i] {
+			t.Errorf("Expected IDOrName %s, got %s", idOrNames[i], result.IDOrName)
+		}
+	}
+}
+
+func TestLabelCmds_processAddBatch_ResourceNotFound(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "nonexistent"}
+	labelsToAdd := map[string]string{"env": "prod"}
+
+	results := cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+
+	if len(results) != 2 {
+		t.Errorf("Expected 2 results, got %d", len(results))
+	}
+
+	// First result should be successful
+	if !results[0].Success {
+		t.Errorf("Expected first result to be successful, got error: %v", results[0].Error)
+	}
+
+	// Second result should fail
+	if results[1].Success {
+		t.Error("Expected second result to fail, but it was successful")
+	}
+
+	if results[1].Error == nil {
+		t.Error("Expected second result to have an error, but it was nil")
+	}
+}
+
+func TestLabelCmds_displayAddResults(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	results := []BatchLabelResult{
+		{IDOrName: "mock1", Success: true, LabelsAdded: []string{"env", "team"}},
+		{IDOrName: "mock2", Success: true, LabelsAdded: []string{"env", "team"}},
+	}
+	labelKeys := []string{"env", "team"}
+
+	// Capture output by redirecting cmd's output
+	// This is a simplified test - in a real scenario you'd capture the output
+	cmds.displayAddResults(cmd, results, labelKeys)
+
+	// Test with failures
+	resultsWithFailures := []BatchLabelResult{
+		{IDOrName: "mock1", Success: true, LabelsAdded: []string{"env"}},
+		{IDOrName: "nonexistent", Success: false, Error: &hcloud.Error{Code: hcloud.ErrorCodeNotFound}},
+	}
+
+	cmds.displayAddResults(cmd, resultsWithFailures, []string{"env"})
+}
+
+func TestLabelCmds_fetchResourcesBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "mock2"}
+
+	resources, errors := cmds.fetchResourcesBatch(mockState, idOrNames)
+
+	if len(resources) != 2 {
+		t.Errorf("Expected 2 resources, got %d", len(resources))
+	}
+
+	if len(errors) != 2 {
+		t.Errorf("Expected 2 errors, got %d", len(errors))
+	}
+
+	for i, resource := range resources {
+		if resource == nil {
+			t.Errorf("Expected resource at index %d to not be nil", i)
+		}
+		if errors[i] != nil {
+			t.Errorf("Expected no error at index %d, got: %v", i, errors[i])
+		}
+	}
+}
+
+func TestLabelCmds_fetchResourcesBatch_WithErrors(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "nonexistent", "mock2"}
+
+	resources, errors := cmds.fetchResourcesBatch(mockState, idOrNames)
+
+	if len(resources) != 3 {
+		t.Errorf("Expected 3 resources, got %d", len(resources))
+	}
+
+	if len(errors) != 3 {
+		t.Errorf("Expected 3 errors, got %d", len(errors))
+	}
+
+	// Check first resource (should succeed)
+	if resources[0] == nil {
+		t.Error("Expected first resource to not be nil")
+	}
+	if errors[0] != nil {
+		t.Errorf("Expected no error for first resource, got: %v", errors[0])
+	}
+
+	// Check second resource (should fail)
+	if resources[1] != nil {
+		t.Error("Expected second resource to be nil due to error")
+	}
+	if errors[1] == nil {
+		t.Error("Expected error for second resource, got nil")
+	}
+
+	// Check third resource (should succeed)
+	if resources[2] == nil {
+		t.Error("Expected third resource to not be nil")
+	}
+	if errors[2] != nil {
+		t.Errorf("Expected no error for third resource, got: %v", errors[2])
+	}
+}
+
+func TestBatchLabelResult_Structure(t *testing.T) {
+	result := BatchLabelResult{
+		IDOrName:         "test-resource",
+		Resource:         &MockResource{ID: 1, Name: "test"},
+		Success:          true,
+		Error:            nil,
+		LabelsAdded:      []string{"env", "team"},
+		LabelsRemoved:    []string{},
+		AllLabelsRemoved: false,
+	}
+
+	if result.IDOrName != "test-resource" {
+		t.Errorf("Expected IDOrName 'test-resource', got '%s'", result.IDOrName)
+	}
+
+	if !result.Success {
+		t.Error("Expected Success to be true")
+	}
+
+	if result.Error != nil {
+		t.Errorf("Expected Error to be nil, got: %v", result.Error)
+	}
+
+	if len(result.LabelsAdded) != 2 {
+		t.Errorf("Expected 2 labels added, got %d", len(result.LabelsAdded))
+	}
+}
+
+func TestLabelBatchSize_Constant(t *testing.T) {
+	if labelBatchSize != 10 {
+		t.Errorf("Expected labelBatchSize to be 10, got %d", labelBatchSize)
+	}
+}
+
+// Benchmark tests for performance validation
+func BenchmarkLabelCmds_RunAddBatch(b *testing.B) {
+	cmds := createMockLabelCmds()
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Create a larger batch for benchmarking
+	args := make([]string, 0, 20)
+	for i := 0; i < 10; i++ {
+		args = append(args, "mock"+string(rune(i+'0')))
+	}
+	args = append(args, "env=prod", "team=backend")
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cmds.RunAddBatch(mockState, cmd, args)
+	}
+}
+
+func BenchmarkLabelCmds_processAddBatch(b *testing.B) {
+	cmds := createMockLabelCmds()
+	var mockState state.State
+
+	idOrNames := make([]string, 10)
+	for i := 0; i < 10; i++ {
+		idOrNames[i] = "mock" + string(rune(i+'0'))
+	}
+	labelsToAdd := map[string]string{"env": "prod", "team": "backend"}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+	}
+}
diff --git a/internal/cmd/loadbalancer/labels.go b/internal/cmd/loadbalancer/labels.go
index 6c5f8e50..728074bc 100644
--- a/internal/cmd/loadbalancer/labels.go
+++ b/internal/cmd/loadbalancer/labels.go
@@ -3,11 +3,13 @@ package loadbalancer
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"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.LoadBalancer]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.LoadBalancer]{
 	GetIDOrName: func(loadBalancer *hcloud.LoadBalancer) string {
 		return strconv.FormatInt(loadBalancer.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.LoadBalancer, []error) {
+		loadBalancers := make([]*hcloud.LoadBalancer, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				loadBalancer, _, err := s.Client().LoadBalancer().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if loadBalancer == nil {
+					errors[idx] = fmt.Errorf("Load Balancer not found: %s", id)
+					return
+				}
+				loadBalancers[idx] = loadBalancer
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return loadBalancers, errors
+	},
+	SetLabelsBatch: func(s state.State, loadBalancers []*hcloud.LoadBalancer, labels map[string]string) []error {
+		errors := make([]error, len(loadBalancers))
+
+		var wg sync.WaitGroup
+		for i, loadBalancer := range loadBalancers {
+			if loadBalancer == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, lb *hcloud.LoadBalancer) {
+				defer wg.Done()
+				opts := hcloud.LoadBalancerUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().LoadBalancer().Update(s, lb, opts)
+				errors[idx] = err
+			}(i, loadBalancer)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }
diff --git a/internal/cmd/network/labels.go b/internal/cmd/network/labels.go
index 1e4888a3..0df609c1 100644
--- a/internal/cmd/network/labels.go
+++ b/internal/cmd/network/labels.go
@@ -3,11 +3,13 @@ package network
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"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.Network]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Network]{
 	GetIDOrName: func(network *hcloud.Network) string {
 		return strconv.FormatInt(network.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Network, []error) {
+		networks := make([]*hcloud.Network, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				network, _, err := s.Client().Network().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if network == nil {
+					errors[idx] = fmt.Errorf("Network not found: %s", id)
+					return
+				}
+				networks[idx] = network
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return networks, errors
+	},
+	SetLabelsBatch: func(s state.State, networks []*hcloud.Network, labels map[string]string) []error {
+		errors := make([]error, len(networks))
+
+		var wg sync.WaitGroup
+		for i, network := range networks {
+			if network == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, net *hcloud.Network) {
+				defer wg.Done()
+				opts := hcloud.NetworkUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Network().Update(s, net, opts)
+				errors[idx] = err
+			}(i, network)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }
diff --git a/internal/cmd/server/labels.go b/internal/cmd/server/labels.go
index bd47213f..a03606d2 100644
--- a/internal/cmd/server/labels.go
+++ b/internal/cmd/server/labels.go
@@ -3,11 +3,13 @@ package server
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
 	state "github.com/hetznercloud/cli/internal/state"
-	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
 var LabelCmds = base.LabelCmds[*hcloud.Server]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Server]{
 	GetIDOrName: func(server *hcloud.Server) string {
 		return strconv.FormatInt(server.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Server, []error) {
+		servers := make([]*hcloud.Server, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				server, _, err := s.Client().Server().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if server == nil {
+					errors[idx] = fmt.Errorf("Server not found: %s", id)
+					return
+				}
+				servers[idx] = server
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return servers, errors
+	},
+	SetLabelsBatch: func(s state.State, servers []*hcloud.Server, labels map[string]string) []error {
+		errors := make([]error, len(servers))
+
+		var wg sync.WaitGroup
+		for i, server := range servers {
+			if server == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, srv *hcloud.Server) {
+				defer wg.Done()
+				opts := hcloud.ServerUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Server().Update(s, srv, opts)
+				errors[idx] = err
+			}(i, server)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }
diff --git a/internal/cmd/volume/labels.go b/internal/cmd/volume/labels.go
index ca16cbd7..dd4619b1 100644
--- a/internal/cmd/volume/labels.go
+++ b/internal/cmd/volume/labels.go
@@ -3,11 +3,13 @@ package volume
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"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.Volume]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Volume]{
 	GetIDOrName: func(volume *hcloud.Volume) string {
 		return strconv.FormatInt(volume.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Volume, []error) {
+		volumes := make([]*hcloud.Volume, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				volume, _, err := s.Client().Volume().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if volume == nil {
+					errors[idx] = fmt.Errorf("Volume not found: %s", id)
+					return
+				}
+				volumes[idx] = volume
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return volumes, errors
+	},
+	SetLabelsBatch: func(s state.State, volumes []*hcloud.Volume, labels map[string]string) []error {
+		errors := make([]error, len(volumes))
+
+		var wg sync.WaitGroup
+		for i, volume := range volumes {
+			if volume == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, vol *hcloud.Volume) {
+				defer wg.Done()
+				opts := hcloud.VolumeUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Volume().Update(s, vol, opts)
+				errors[idx] = err
+			}(i, volume)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }