diff --git a/v2/CHANGELOG.md b/v2/CHANGELOG.md
index a87f089d..c28d83db 100644
--- a/v2/CHANGELOG.md
+++ b/v2/CHANGELOG.md
@@ -16,6 +16,7 @@
 - Switch to Go 1.21.8
 - multi_delimiter analyzer support
 - Wildcard analyzer support
+- Backup API support
 
 
 ## [2.0.3](https://github.com/arangodb/go-driver/tree/v2.0.3) (2023-10-31)
diff --git a/v2/arangodb/client_admin.go b/v2/arangodb/client_admin.go
index 9c1ad343..7a6d5af5 100644
--- a/v2/arangodb/client_admin.go
+++ b/v2/arangodb/client_admin.go
@@ -1,7 +1,7 @@
 //
 // DISCLAIMER
 //
-// Copyright 2023 ArangoDB GmbH, Cologne, Germany
+// Copyright 2023-2024 ArangoDB GmbH, Cologne, Germany
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -43,12 +43,10 @@ type ClientAdmin interface {
 	SetServerMode(ctx context.Context, mode ServerMode) error
 }
 
-type ClientAdminBackup interface {
-}
-
 type ClientAdminLog interface {
 	// GetLogLevels returns log levels for topics.
 	GetLogLevels(ctx context.Context, opts *LogLevelsGetOptions) (LogLevels, error)
+
 	// SetLogLevels sets log levels for a given topics.
 	SetLogLevels(ctx context.Context, logLevels LogLevels, opts *LogLevelsSetOptions) error
 }
diff --git a/v2/arangodb/client_admin_backup.go b/v2/arangodb/client_admin_backup.go
new file mode 100644
index 00000000..30360f10
--- /dev/null
+++ b/v2/arangodb/client_admin_backup.go
@@ -0,0 +1,137 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package arangodb
+
+import (
+	"context"
+	"time"
+)
+
+type ClientAdminBackup interface {
+	// BackupCreate creates a new backup and returns its id
+	BackupCreate(ctx context.Context, opt *BackupCreateOptions) (BackupResponse, error)
+
+	// BackupRestore restores the backup with given id
+	BackupRestore(ctx context.Context, id string) (BackupRestoreResponse, error)
+
+	// BackupDelete deletes the backup with given id
+	BackupDelete(ctx context.Context, id string) error
+
+	// BackupList returns meta data about some/all backups available
+	BackupList(ctx context.Context, opt *BackupListOptions) (ListBackupsResponse, error)
+
+	// BackupUpload triggers an upload of backup into the remote repository using the given config
+	BackupUpload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error)
+
+	// BackupDownload triggers a download of backup into the remote repository using the given config
+	BackupDownload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error)
+}
+
+type TransferMonitor interface {
+	// Progress returns the progress of the transfer (upload/download)
+	Progress(ctx context.Context) (BackupTransferProgressResponse, error)
+
+	// Abort the transfer (upload/download)
+	Abort(ctx context.Context) error
+}
+
+type BackupCreateOptions struct {
+	// The label for this backup.
+	// The label is used together with a timestamp string create a unique backup identifier, <timestamp>_<label>.
+	// Default: If omitted or empty, a UUID will be generated.
+	Label string `json:"label,omitempty"`
+
+	// The time in seconds that the operation tries to get a consistent snapshot. The default is 120 seconds.
+	Timeout *uint `json:"timeout,omitempty"`
+
+	// If set to `true` and no global transaction lock can be acquired within the
+	// given timeout, a possibly inconsistent backup is taken.
+	AllowInconsistent *bool `json:"allowInconsistent,omitempty"`
+
+	// (Enterprise Edition cluster only.) If set to `true` and no global transaction lock can be acquired within the
+	// given timeout, all running transactions are forcefully aborted to ensure that a consistent backup can be created.
+	Force *bool `json:"force,omitempty"`
+}
+
+type BackupResponse struct {
+	ID                      string    `json:"id,omitempty"`
+	PotentiallyInconsistent bool      `json:"potentiallyInconsistent,omitempty"`
+	NumberOfFiles           uint      `json:"nrFiles,omitempty"`
+	NumberOfDBServers       uint      `json:"nrDBServers,omitempty"`
+	SizeInBytes             uint64    `json:"sizeInBytes,omitempty"`
+	CreationTime            time.Time `json:"datetime,omitempty"`
+}
+
+type BackupRestoreResponse struct {
+	Previous string `json:"previous,omitempty"`
+}
+
+type BackupListOptions struct {
+	// Set to receive info about specific single backup
+	ID string `json:"id,omitempty"`
+}
+
+type ListBackupsResponse struct {
+	Server  string                `json:"server,omitempty"`
+	Backups map[string]BackupMeta `json:"list,omitempty"`
+}
+
+type BackupMeta struct {
+	BackupResponse
+
+	Version               string             `json:"version,omitempty"`
+	Available             bool               `json:"available,omitempty"`
+	NumberOfPiecesPresent uint               `json:"nrPiecesPresent,omitempty"`
+	Keys                  []BackupMetaSha256 `json:"keys,omitempty"`
+}
+
+type BackupMetaSha256 struct {
+	SHA256 string `json:"sha256"`
+}
+
+// BackupTransferStatus represents all possible states a transfer job can be in
+type BackupTransferStatus string
+
+const (
+	TransferAcknowledged BackupTransferStatus = "ACK"
+	TransferStarted      BackupTransferStatus = "STARTED"
+	TransferCompleted    BackupTransferStatus = "COMPLETED"
+	TransferFailed       BackupTransferStatus = "FAILED"
+	TransferCancelled    BackupTransferStatus = "CANCELLED"
+)
+
+type BackupTransferProgressResponse struct {
+	BackupID  string                          `json:"BackupId,omitempty"`
+	Cancelled bool                            `json:"Cancelled,omitempty"`
+	Timestamp string                          `json:"Timestamp,omitempty"`
+	DBServers map[string]BackupTransferReport `json:"DBServers,omitempty"`
+}
+
+type BackupTransferReport struct {
+	Status       BackupTransferStatus `json:"Status,omitempty"`
+	Error        int                  `json:"Error,omitempty"`
+	ErrorMessage string               `json:"ErrorMessage,omitempty"`
+	Progress     struct {
+		Total     int    `json:"Total,omitempty"`
+		Done      int    `json:"Done,omitempty"`
+		Timestamp string `json:"Timestamp,omitempty"`
+	} `json:"Progress,omitempty"`
+}
diff --git a/v2/arangodb/client_admin_backup_impl.go b/v2/arangodb/client_admin_backup_impl.go
new file mode 100644
index 00000000..6ab453ed
--- /dev/null
+++ b/v2/arangodb/client_admin_backup_impl.go
@@ -0,0 +1,344 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package arangodb
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/pkg/errors"
+
+	"github.com/arangodb/go-driver/v2/arangodb/shared"
+	"github.com/arangodb/go-driver/v2/connection"
+)
+
+func (c clientAdmin) BackupCreate(ctx context.Context, opt *BackupCreateOptions) (BackupResponse, error) {
+	url := connection.NewUrl("_admin", "backup", "create")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		BackupResponse        BackupResponse `json:"result,omitempty"`
+	}
+
+	var modifiers []connection.RequestModifier
+	if opt != nil {
+		modifiers = append(modifiers, connection.WithBody(opt))
+	}
+
+	resp, err := connection.Call(ctx, c.client.connection, http.MethodPost, url, &response, modifiers...)
+	if err != nil {
+		return BackupResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusCreated:
+		return response.BackupResponse, nil
+	default:
+		return BackupResponse{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c clientAdmin) BackupRestore(ctx context.Context, id string) (BackupRestoreResponse, error) {
+	url := connection.NewUrl("_admin", "backup", "restore")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		BackupRestoreResponse BackupRestoreResponse `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID string `json:"id,omitempty"`
+	}{
+		ID: id,
+	}
+
+	resp, err := connection.CallPost(ctx, c.client.connection, url, &response, body)
+	if err != nil {
+		return BackupRestoreResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.BackupRestoreResponse, nil
+	default:
+		return BackupRestoreResponse{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c clientAdmin) BackupDelete(ctx context.Context, id string) error {
+	url := connection.NewUrl("_admin", "backup", "delete")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+	}
+
+	body := struct {
+		ID string `json:"id,omitempty"`
+	}{
+		ID: id,
+	}
+
+	resp, err := connection.CallPost(ctx, c.client.connection, url, &response, body)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return nil
+	default:
+		return response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c clientAdmin) BackupList(ctx context.Context, opt *BackupListOptions) (ListBackupsResponse, error) {
+	url := connection.NewUrl("_admin", "backup", "list")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		ListBackupsResponse   ListBackupsResponse `json:"result,omitempty"`
+	}
+
+	var modifiers []connection.RequestModifier
+	if opt != nil {
+		modifiers = append(modifiers, connection.WithBody(opt))
+	}
+
+	resp, err := connection.Call(ctx, c.client.connection, http.MethodPost, url, &response, modifiers...)
+	if err != nil {
+		return ListBackupsResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.ListBackupsResponse, nil
+	default:
+		return ListBackupsResponse{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c clientAdmin) BackupUpload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error) {
+	url := connection.NewUrl("_admin", "backup", "upload")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		Result                struct {
+			UploadID string `json:"uploadId,omitempty"`
+		} `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID         string      `json:"id,omitempty"`
+		RemoteRepo string      `json:"remoteRepository,omitempty"`
+		Config     interface{} `json:"config,omitempty"`
+	}{
+		ID:         backupId,
+		RemoteRepo: remoteRepository,
+		Config:     config,
+	}
+
+	resp, err := connection.CallPost(ctx, c.client.connection, url, &response, body)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusAccepted:
+		return newUploadMonitor(c.client, response.Result.UploadID)
+	default:
+		return nil, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c clientAdmin) BackupDownload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error) {
+	url := connection.NewUrl("_admin", "backup", "download")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		Result                struct {
+			DownloadID string `json:"downloadId,omitempty"`
+		} `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID         string      `json:"id,omitempty"`
+		RemoteRepo string      `json:"remoteRepository,omitempty"`
+		Config     interface{} `json:"config,omitempty"`
+	}{
+		ID:         backupId,
+		RemoteRepo: remoteRepository,
+		Config:     config,
+	}
+
+	resp, err := connection.CallPost(ctx, c.client.connection, url, &response, body)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusAccepted:
+		return newDownloadMonitor(c.client, response.Result.DownloadID)
+	default:
+		return nil, response.AsArangoErrorWithCode(code)
+	}
+}
+
+type uploadMonitor struct {
+	client *client
+	jobId  string
+}
+
+func newUploadMonitor(c *client, jobId string) (uploadMonitor, error) {
+	if jobId == "" {
+		return uploadMonitor{}, errors.New("jobId must not be empty")
+	}
+	return uploadMonitor{
+		client: c,
+		jobId:  jobId,
+	}, nil
+}
+
+func (u uploadMonitor) Progress(ctx context.Context) (BackupTransferProgressResponse, error) {
+	url := connection.NewUrl("_admin", "backup", "upload")
+
+	var response struct {
+		shared.ResponseStruct          `json:",inline"`
+		BackupTransferProgressResponse BackupTransferProgressResponse `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID string `json:"uploadId,omitempty"`
+	}{
+		ID: u.jobId,
+	}
+
+	resp, err := connection.CallPost(ctx, u.client.connection, url, &response, body)
+	if err != nil {
+		return BackupTransferProgressResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.BackupTransferProgressResponse, nil
+	default:
+		return BackupTransferProgressResponse{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (u uploadMonitor) Abort(ctx context.Context) error {
+	url := connection.NewUrl("_admin", "backup", "upload")
+
+	var response struct {
+		shared.ResponseStruct          `json:",inline"`
+		BackupTransferProgressResponse BackupTransferProgressResponse `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID    string `json:"uploadId,omitempty"`
+		Abort bool   `json:"abort,omitempty"`
+	}{
+		ID:    u.jobId,
+		Abort: true,
+	}
+
+	resp, err := connection.CallPost(ctx, u.client.connection, url, &response, body)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusAccepted:
+		return nil
+	default:
+		return response.AsArangoErrorWithCode(code)
+	}
+}
+
+type downloadMonitor struct {
+	client *client
+	jobId  string
+}
+
+func newDownloadMonitor(c *client, jobId string) (downloadMonitor, error) {
+	if jobId == "" {
+		return downloadMonitor{}, errors.New("jobId must not be empty")
+	}
+	return downloadMonitor{
+		client: c,
+		jobId:  jobId,
+	}, nil
+}
+
+func (d downloadMonitor) Progress(ctx context.Context) (BackupTransferProgressResponse, error) {
+	url := connection.NewUrl("_admin", "backup", "download")
+
+	var response struct {
+		shared.ResponseStruct          `json:",inline"`
+		BackupTransferProgressResponse BackupTransferProgressResponse `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID string `json:"downloadId,omitempty"`
+	}{
+		ID: d.jobId,
+	}
+
+	resp, err := connection.CallPost(ctx, d.client.connection, url, &response, body)
+	if err != nil {
+		return BackupTransferProgressResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.BackupTransferProgressResponse, nil
+	default:
+		return BackupTransferProgressResponse{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (d downloadMonitor) Abort(ctx context.Context) error {
+	url := connection.NewUrl("_admin", "backup", "upload")
+
+	var response struct {
+		shared.ResponseStruct          `json:",inline"`
+		BackupTransferProgressResponse BackupTransferProgressResponse `json:"result,omitempty"`
+	}
+
+	body := struct {
+		ID    string `json:"downloadId,omitempty"`
+		Abort bool   `json:"abort,omitempty"`
+	}{
+		ID:    d.jobId,
+		Abort: true,
+	}
+
+	resp, err := connection.CallPost(ctx, d.client.connection, url, &response, body)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusAccepted:
+		return nil
+	default:
+		return response.AsArangoErrorWithCode(code)
+	}
+}
diff --git a/v2/tests/admin_log_test.go b/v2/tests/admin_log_test.go
index f426b35f..916f4ea8 100644
--- a/v2/tests/admin_log_test.go
+++ b/v2/tests/admin_log_test.go
@@ -23,6 +23,7 @@ package tests
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -67,7 +68,7 @@ func Test_LogLevels(t *testing.T) {
 func Test_LogLevelsForServers(t *testing.T) {
 	requireMode(t, testModeCluster, testModeResilientSingle)
 
-	// This test can not run subtests parallelly, because it changes admin settings.
+	// This test can not run subtests parallel, because it changes admin settings.
 	wrapOpts := WrapOptions{
 		Parallel: newBool(false),
 	}
@@ -75,7 +76,7 @@ func Test_LogLevelsForServers(t *testing.T) {
 	Wrap(t, func(t *testing.T, client arangodb.Client) {
 		withContextT(t, defaultTestTimeout, func(ctx context.Context, _ testing.TB) {
 			skipBelowVersion(client, ctx, "3.10.2", t)
-			withHealthT(t, ctx, client, func(t *testing.T, ctx context.Context, health arangodb.ClusterHealth) {
+			withHealthT(t, ctx, client, time.Second*30, func(t *testing.T, ctx context.Context, health arangodb.ClusterHealth) {
 				var changed int
 				servers := make(map[arangodb.ServerID]arangodb.LogLevels)
 				for serverID, health := range health.Health {
diff --git a/v2/tests/backup_test.go b/v2/tests/backup_test.go
new file mode 100644
index 00000000..c77fff35
--- /dev/null
+++ b/v2/tests/backup_test.go
@@ -0,0 +1,295 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package tests
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/arangodb/go-driver/v2/arangodb"
+)
+
+func Test_CreateBackupSimple(t *testing.T) {
+	Wrap(t, func(t *testing.T, client arangodb.Client) {
+		withContextT(t, defaultTestTimeout, func(ctx context.Context, tb testing.TB) {
+			backup, err := client.BackupCreate(ctx, nil)
+			require.NoError(t, err, "CreateBackup failed")
+			require.NotNil(t, backup, "CreateBackup did not return a backup")
+
+			t.Run("Create Backup with options", func(t *testing.T) {
+				opts := &arangodb.BackupCreateOptions{
+					Label: "test",
+				}
+
+				backupWithOpts, err := client.BackupCreate(ctx, opts)
+				require.NoError(t, err, "CreateBackup failed")
+				require.NotNil(t, backupWithOpts, "CreateBackup did not return a backup")
+				require.True(t, strings.HasSuffix(backupWithOpts.ID, "test"))
+
+				defer func() {
+					err = client.BackupDelete(ctx, backupWithOpts.ID)
+					require.NoError(t, err, "DeleteBackup failed")
+				}()
+			})
+
+			backups, err := client.BackupList(ctx, nil)
+			require.NoError(t, err, "BackupList failed")
+			require.NotNil(t, backups, "BackupList did not return a list of backups")
+			require.Contains(t, backups.Backups, backup.ID, "BackupList did not return the created backup")
+
+			t.Run("List with single", func(t *testing.T) {
+				opt := &arangodb.BackupListOptions{
+					ID: backup.ID,
+				}
+				backupsWithOpts, err := client.BackupList(ctx, opt)
+				require.NoError(t, err, "BackupList failed")
+				require.NotNil(t, backupsWithOpts, "BackupList did not return a list of backups")
+				require.Contains(t, backupsWithOpts.Backups, backup.ID, "BackupList did not return the created backup")
+				require.Len(t, backupsWithOpts.Backups, 1, "BackupList did not return the correct number of backups")
+
+			})
+
+			backupMeta := backups.Backups[backup.ID]
+			require.Greater(t, backupMeta.NumberOfFiles, uint(0))
+			require.Greater(t, backupMeta.NumberOfDBServers, uint(0))
+			require.Greater(t, backupMeta.SizeInBytes, uint64(0))
+
+			err = client.BackupDelete(ctx, backup.ID)
+			require.NoError(t, err, "DeleteBackup failed")
+		})
+	}, WrapOptions{
+		Parallel: newBool(false),
+	})
+}
+
+func Test_RestoreBackupSimple(t *testing.T) {
+	requireClusterMode(t)
+
+	Wrap(t, func(t *testing.T, client arangodb.Client) {
+		WithDatabase(t, client, nil, func(db arangodb.Database) {
+			WithCollection(t, db, nil, func(col arangodb.Collection) {
+				withContextT(t, defaultTestTimeout, func(ctx context.Context, tb testing.TB) {
+					book1 := DocWithRev{
+						Name: "Hello World",
+					}
+
+					meta1, err := col.CreateDocument(ctx, book1)
+					require.NoError(t, err)
+
+					backup, err := client.BackupCreate(ctx, nil)
+					require.NoError(t, err, "CreateBackup failed")
+					require.NotNil(t, backup, "CreateBackup did not return a backup")
+
+					book2 := DocWithRev{
+						Name: "How to Backups",
+					}
+					meta2, err := col.CreateDocument(ctx, book2)
+					require.NoError(t, err)
+
+					t.Run("Restore Backup", func(t *testing.T) {
+						resp, err := client.BackupRestore(ctx, backup.ID)
+						require.NoError(t, err, "RestoreBackup failed")
+						require.NotNil(t, resp, "RestoreBackup did not return a task")
+						require.NotEmpty(t, resp.Previous)
+
+						waitForHealthyClusterAfterBackup(t, ctx, client)
+					})
+
+					exist, err := col.DocumentExists(ctx, meta1.Key)
+					require.NoError(t, err)
+					require.True(t, exist)
+
+					exist, err = col.DocumentExists(ctx, meta2.Key)
+					require.NoError(t, err)
+					require.False(t, exist)
+
+					err = client.BackupDelete(ctx, backup.ID)
+					require.NoError(t, err, "DeleteBackup failed")
+				})
+			})
+		})
+	}, WrapOptions{
+		Parallel: newBool(false),
+	})
+}
+
+func Test_BackupFullFlow(t *testing.T) {
+	requireClusterMode(t)
+
+	Wrap(t, func(t *testing.T, client arangodb.Client) {
+		withContextT(t, defaultTestTimeout, func(ctx context.Context, tb testing.TB) {
+			skipNoEnterprise(client, ctx, t)
+
+			repo, config := getTransferConfigFromEnv(t)
+
+			backup, err := client.BackupCreate(ctx, nil)
+			require.NoError(t, err, "CreateBackup failed")
+			require.NotNil(t, backup, "CreateBackup did not return a backup")
+
+			t.Run("Upload Backup", func(t *testing.T) {
+				tf, err := client.BackupUpload(ctx, backup.ID, repo, config)
+				require.NoError(t, err, "UploadBackup failed")
+				require.NotNil(t, tf)
+
+				waitForTransferJobCompletion(t, ctx, tf, false, false)
+			})
+
+			t.Run("Delete Backup", func(t *testing.T) {
+				err = client.BackupDelete(ctx, backup.ID)
+				require.NoError(t, err, "DeleteBackup failed")
+			})
+
+			t.Run("Download Backup", func(t *testing.T) {
+				tf, err := client.BackupDownload(ctx, backup.ID, repo, config)
+				require.NoError(t, err, "DownloadBackup failed")
+				require.NotNil(t, tf)
+
+				waitForTransferJobCompletion(t, ctx, tf, false, false)
+			})
+
+			t.Run("Restore Backup", func(t *testing.T) {
+				resp, err := client.BackupRestore(ctx, backup.ID)
+				require.NoError(t, err, "RestoreBackup failed")
+				require.NotNil(t, resp, "RestoreBackup did not return a task")
+				require.NotEmpty(t, resp.Previous)
+
+				waitForHealthyClusterAfterBackup(t, ctx, client)
+			})
+
+		})
+	}, WrapOptions{
+		Parallel: newBool(false),
+	})
+}
+
+func Test_UploadBackupFailAndAbort(t *testing.T) {
+	Wrap(t, func(t *testing.T, client arangodb.Client) {
+		withContextT(t, defaultTestTimeout, func(ctx context.Context, tb testing.TB) {
+			skipNoEnterprise(client, ctx, t)
+
+			t.Run("Upload Backup not existing backup", func(t *testing.T) {
+				repo, config := getTransferConfigFromEnv(t)
+
+				tf, err := client.BackupUpload(ctx, "not_there", repo, config)
+				require.NoError(t, err, "UploadBackup failed")
+				require.NotNil(t, tf)
+
+				waitForTransferJobCompletion(t, ctx, tf, true, false)
+			})
+
+			t.Run("Upload Backup aborted", func(t *testing.T) {
+				repo, config := getTransferConfigFromEnv(t)
+
+				backup, err := client.BackupCreate(ctx, nil)
+				require.NoError(t, err, "CreateBackup failed")
+				require.NotNil(t, backup, "CreateBackup did not return a backup")
+
+				tf, err := client.BackupUpload(ctx, backup.ID, repo, config)
+				require.NoError(t, err, "UploadBackup failed")
+				require.NotNil(t, tf)
+
+				require.NoError(t, tf.Abort(ctx))
+
+				waitForTransferJobCompletion(t, ctx, tf, false, true)
+			})
+		})
+	}, WrapOptions{
+		Parallel: newBool(false),
+	})
+}
+
+func waitForHealthyClusterAfterBackup(t *testing.T, ctx context.Context, client arangodb.Client) {
+	time.Sleep(5 * time.Second)
+	withHealthT(t, ctx, client, time.Second*30, func(t *testing.T, ctx context.Context, health arangodb.ClusterHealth) {
+
+	})
+}
+
+func waitForTransferJobCompletion(t *testing.T, ctx context.Context, tf arangodb.TransferMonitor, shouldFail, shouldAbort bool) {
+	for {
+		progress, err := tf.Progress(ctx)
+		require.NoError(t, err)
+
+		// Wait for completion
+		completedCount := 0
+		for dbServer, status := range progress.DBServers {
+			switch status.Status {
+			case arangodb.TransferCompleted:
+				if !shouldFail && !shouldAbort {
+					completedCount++
+					break
+				} else {
+					t.Fatalf("Upload should not complete: %s", dbServer)
+				}
+			case arangodb.TransferFailed:
+				if shouldFail {
+					completedCount++
+					break
+				} else {
+					t.Fatalf("Job on %s failed: %s (%d)", dbServer, status.ErrorMessage, status.Error)
+				}
+			case arangodb.TransferCancelled:
+				if shouldAbort {
+					completedCount++
+					break
+				}
+				t.Fatalf("Job on %s was cancelled", dbServer)
+			}
+
+			t.Logf("Status on %s: %s (%d / %d)", dbServer, status.Status, status.Progress.Done, status.Progress.Total)
+		}
+
+		if completedCount == len(progress.DBServers) {
+			break
+		}
+
+		select {
+		case <-ctx.Done():
+			t.Fatalf("Job failed: %s", ctx.Err())
+		case <-time.After(8 * time.Second):
+			break
+		}
+	}
+}
+
+func getTransferConfigFromEnv(t *testing.T) (repo string, config map[string]json.RawMessage) {
+	repoEnv := os.Getenv("TEST_BACKUP_REMOTE_REPO")
+	confEnv := os.Getenv("TEST_BACKUP_REMOTE_CONFIG")
+
+	if repoEnv == "" || confEnv == "" {
+		t.Skipf("TEST_BACKUP_REMOTE_REPO and TEST_BACKUP_REMOTE_CONFIG must be set for remote transfer tests")
+	}
+
+	var confMap map[string]json.RawMessage
+	err := json.Unmarshal([]byte(confEnv), &confMap)
+	require.NoError(t, err, "Failed to unmarshal remote config")
+
+	require.NotEmpty(t, repoEnv)
+	require.NotEmpty(t, confMap)
+
+	return repoEnv, confMap
+}
diff --git a/v2/tests/database_analyzer_test.go b/v2/tests/database_analyzer_test.go
index acdc8a71..df0ae026 100644
--- a/v2/tests/database_analyzer_test.go
+++ b/v2/tests/database_analyzer_test.go
@@ -67,7 +67,8 @@ func Test_Analyzers(t *testing.T) {
 			HasError: true,
 		},
 		{
-			Name: "create-my-multi-delimiters",
+			Name:       "create-my-multi-delimiters",
+			MinVersion: newVersion("3.12"),
 			Definition: arangodb.AnalyzerDefinition{
 				Name: "my-multidelimiters",
 				Type: arangodb.ArangoSearchAnalyzerTypeMultiDelimiter,
@@ -329,7 +330,8 @@ func Test_Analyzers(t *testing.T) {
 			},
 		},
 		{
-			Name: "create-my-wildcard",
+			Name:       "create-my-wildcard",
+			MinVersion: newVersion("3.12"),
 			Definition: arangodb.AnalyzerDefinition{
 				Name: "my-wildcard",
 				Type: arangodb.ArangoSearchAnalyzerTypeWildcard,
diff --git a/v2/tests/run_wrap_test.go b/v2/tests/run_wrap_test.go
index 483b4cc1..5b4e1148 100644
--- a/v2/tests/run_wrap_test.go
+++ b/v2/tests/run_wrap_test.go
@@ -388,13 +388,13 @@ type healthFunc func(*testing.T, context.Context, arangodb.ClusterHealth)
 
 // withHealth waits for health, and launches a given function when it is healthy.
 // When systems are available, then sometimes it needs more time to fetch healthiness.
-func withHealthT(t *testing.T, ctx context.Context, client arangodb.Client, f healthFunc) {
+func withHealthT(t *testing.T, ctx context.Context, client arangodb.Client, timeout time.Duration, f healthFunc) {
 	ctxInner := ctx
 	if _, ok := ctx.Deadline(); !ok {
 		// When a caller does not provide timeout, wait for healthiness for 30 seconds.
 		var cancel context.CancelFunc
 
-		ctxInner, cancel = context.WithTimeout(ctx, time.Second*30)
+		ctxInner, cancel = context.WithTimeout(ctx, timeout)
 		defer cancel()
 	}