diff --git a/apps/dokploy/components/dashboard/settings/destination/constants.ts b/apps/dokploy/components/dashboard/settings/destination/constants.ts
index f43e47d1a1..096c76d8f4 100644
--- a/apps/dokploy/components/dashboard/settings/destination/constants.ts
+++ b/apps/dokploy/components/dashboard/settings/destination/constants.ts
@@ -131,3 +131,27 @@ export const S3_PROVIDERS: Array<{
 		name: "Any other S3 compatible provider",
 	},
 ];
+
+export const DESTINATION_TYPES: Array<{
+	key: "s3" | "sftp" | "rclone";
+	name: string;
+	description: string;
+}> = [
+	{
+		key: "s3",
+		name: "S3 Compatible",
+		description:
+			"Amazon S3, Cloudflare R2, DigitalOcean Spaces, MinIO, and other S3-compatible storage",
+	},
+	{
+		key: "sftp",
+		name: "SFTP / SSH",
+		description: "Upload backups via SFTP to any remote server",
+	},
+	{
+		key: "rclone",
+		name: "Rclone (Custom)",
+		description:
+			"Use a custom rclone configuration to support Google Drive, OneDrive, Azure Blob, FTP, and many more providers",
+	},
+];
diff --git a/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx b/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
index dae069e919..e716a2cd0e 100644
--- a/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
+++ b/apps/dokploy/components/dashboard/settings/destination/handle-destinations.tsx
@@ -33,18 +33,32 @@ import {
 	SelectTrigger,
 	SelectValue,
 } from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
 import { cn } from "@/lib/utils";
 import { api } from "@/utils/api";
-import { S3_PROVIDERS } from "./constants";
+import { DESTINATION_TYPES, S3_PROVIDERS } from "./constants";
 
 const addDestination = z.object({
 	name: z.string().min(1, "Name is required"),
-	provider: z.string().min(1, "Provider is required"),
-	accessKeyId: z.string().min(1, "Access Key Id is required"),
-	secretAccessKey: z.string().min(1, "Secret Access Key is required"),
-	bucket: z.string().min(1, "Bucket is required"),
-	region: z.string(),
-	endpoint: z.string().min(1, "Endpoint is required"),
+	destinationType: z.enum(["s3", "sftp", "rclone"]).default("s3"),
+	// S3 fields
+	provider: z.string().optional(),
+	accessKeyId: z.string().optional(),
+	secretAccessKey: z.string().optional(),
+	bucket: z.string().optional(),
+	region: z.string().optional(),
+	endpoint: z.string().optional(),
+	// SFTP fields
+	sftpHost: z.string().optional(),
+	sftpPort: z.number().optional(),
+	sftpUsername: z.string().optional(),
+	sftpPassword: z.string().optional(),
+	sftpKeyPath: z.string().optional(),
+	sftpRemotePath: z.string().optional(),
+	// Rclone fields
+	rcloneConfig: z.string().optional(),
+	rcloneRemoteName: z.string().optional(),
+	rcloneRemotePath: z.string().optional(),
 	serverId: z.string().optional(),
 });
 
@@ -82,6 +96,7 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 
 	const form = useForm<AddDestination>({
 		defaultValues: {
+			destinationType: "s3",
 			provider: "",
 			accessKeyId: "",
 			bucket: "",
@@ -89,19 +104,41 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 			region: "",
 			secretAccessKey: "",
 			endpoint: "",
+			sftpHost: "",
+			sftpPort: 22,
+			sftpUsername: "",
+			sftpPassword: "",
+			sftpKeyPath: "",
+			sftpRemotePath: "/backups",
+			rcloneConfig: "",
+			rcloneRemoteName: "",
+			rcloneRemotePath: "",
 		},
 		resolver: zodResolver(addDestination),
 	});
+
+	const destinationType = form.watch("destinationType");
+
 	useEffect(() => {
 		if (destination) {
 			form.reset({
 				name: destination.name,
+				destinationType: destination.destinationType || "s3",
 				provider: destination.provider || "",
 				accessKeyId: destination.accessKey,
 				secretAccessKey: destination.secretAccessKey,
 				bucket: destination.bucket,
 				region: destination.region,
 				endpoint: destination.endpoint,
+				sftpHost: destination.sftpHost || "",
+				sftpPort: destination.sftpPort || 22,
+				sftpUsername: destination.sftpUsername || "",
+				sftpPassword: destination.sftpPassword || "",
+				sftpKeyPath: destination.sftpKeyPath || "",
+				sftpRemotePath: destination.sftpRemotePath || "/backups",
+				rcloneConfig: destination.rcloneConfig || "",
+				rcloneRemoteName: destination.rcloneRemoteName || "",
+				rcloneRemotePath: destination.rcloneRemotePath || "",
 			});
 		} else {
 			form.reset();
@@ -110,14 +147,24 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 
 	const onSubmit = async (data: AddDestination) => {
 		await mutateAsync({
+			destinationType: data.destinationType || "s3",
 			provider: data.provider || "",
-			accessKey: data.accessKeyId,
-			bucket: data.bucket,
-			endpoint: data.endpoint,
+			accessKey: data.accessKeyId || "",
+			bucket: data.bucket || "",
+			endpoint: data.endpoint || "",
 			name: data.name,
-			region: data.region,
-			secretAccessKey: data.secretAccessKey,
+			region: data.region || "",
+			secretAccessKey: data.secretAccessKey || "",
 			destinationId: destinationId || "",
+			sftpHost: data.sftpHost || undefined,
+			sftpPort: data.sftpPort || undefined,
+			sftpUsername: data.sftpUsername || undefined,
+			sftpPassword: data.sftpPassword || undefined,
+			sftpKeyPath: data.sftpKeyPath || undefined,
+			sftpRemotePath: data.sftpRemotePath || undefined,
+			rcloneConfig: data.rcloneConfig || undefined,
+			rcloneRemoteName: data.rcloneRemoteName || undefined,
+			rcloneRemotePath: data.rcloneRemotePath || undefined,
 		})
 			.then(async () => {
 				toast.success(`Destination ${destinationId ? "Updated" : "Created"}`);
@@ -135,25 +182,39 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 	};
 
 	const handleTestConnection = async (serverId?: string) => {
-		const result = await form.trigger([
-			"provider",
-			"accessKeyId",
-			"secretAccessKey",
-			"bucket",
-			"endpoint",
-		]);
-
-		if (!result) {
-			const errors = form.formState.errors;
-			const errorFields = Object.entries(errors)
-				.map(([field, error]) => `${field}: ${error?.message}`)
-				.filter(Boolean)
-				.join("\n");
+		const destType = form.getValues("destinationType") || "s3";
 
-			toast.error("Please fill all required fields", {
-				description: errorFields,
-			});
-			return;
+		if (destType === "s3") {
+			const result = await form.trigger([
+				"provider",
+				"accessKeyId",
+				"secretAccessKey",
+				"bucket",
+				"endpoint",
+			]);
+			if (!result) {
+				const errors = form.formState.errors;
+				const errorFields = Object.entries(errors)
+					.map(([field, error]) => `${field}: ${error?.message}`)
+					.filter(Boolean)
+					.join("\n");
+				toast.error("Please fill all required fields", {
+					description: errorFields,
+				});
+				return;
+			}
+		} else if (destType === "sftp") {
+			const result = await form.trigger(["sftpHost", "sftpUsername"]);
+			if (!result) {
+				toast.error("Please fill host and username");
+				return;
+			}
+		} else if (destType === "rclone") {
+			const result = await form.trigger(["rcloneConfig", "rcloneRemoteName"]);
+			if (!result) {
+				toast.error("Please fill rclone config and remote name");
+				return;
+			}
 		}
 
 		if (isCloud && !serverId) {
@@ -161,31 +222,32 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 			return;
 		}
 
-		const provider = form.getValues("provider");
-		const accessKey = form.getValues("accessKeyId");
-		const secretKey = form.getValues("secretAccessKey");
-		const bucket = form.getValues("bucket");
-		const endpoint = form.getValues("endpoint");
-		const region = form.getValues("region");
-
-		const connectionString = `:s3,provider=${provider},access_key_id=${accessKey},secret_access_key=${secretKey},endpoint=${endpoint}${region ? `,region=${region}` : ""}:${bucket}`;
-
 		await testConnection({
-			provider,
-			accessKey,
-			bucket,
-			endpoint,
+			destinationType: destType,
+			provider: form.getValues("provider") || "",
+			accessKey: form.getValues("accessKeyId") || "",
+			bucket: form.getValues("bucket") || "",
+			endpoint: form.getValues("endpoint") || "",
 			name: "Test",
-			region,
-			secretAccessKey: secretKey,
+			region: form.getValues("region") || "",
+			secretAccessKey: form.getValues("secretAccessKey") || "",
+			sftpHost: form.getValues("sftpHost") || undefined,
+			sftpPort: form.getValues("sftpPort") || undefined,
+			sftpUsername: form.getValues("sftpUsername") || undefined,
+			sftpPassword: form.getValues("sftpPassword") || undefined,
+			sftpKeyPath: form.getValues("sftpKeyPath") || undefined,
+			sftpRemotePath: form.getValues("sftpRemotePath") || undefined,
+			rcloneConfig: form.getValues("rcloneConfig") || undefined,
+			rcloneRemoteName: form.getValues("rcloneRemoteName") || undefined,
+			rcloneRemotePath: form.getValues("rcloneRemotePath") || undefined,
 			serverId,
 		})
 			.then(() => {
 				toast.success("Connection Success");
 			})
 			.catch((e) => {
-				toast.error("Error connecting to provider", {
-					description: `${e.message}\n\nTry manually: rclone ls ${connectionString}`,
+				toast.error("Error connecting to destination", {
+					description: e.message,
 				});
 			});
 	};
@@ -208,15 +270,15 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 					</Button>
 				)}
 			</DialogTrigger>
-			<DialogContent className="sm:max-w-2xl">
+			<DialogContent className="sm:max-w-2xl max-h-[85vh] overflow-y-auto">
 				<DialogHeader>
 					<DialogTitle>
 						{destinationId ? "Update" : "Add"} Destination
 					</DialogTitle>
 					<DialogDescription>
-						In this section, you can configure and add new destinations for your
-						backups. Please ensure that you provide the correct information to
-						guarantee secure and efficient storage.
+						Configure a backup destination. Choose from S3-compatible storage,
+						SFTP servers, or use a custom rclone configuration for providers
+						like Google Drive, OneDrive, Azure Blob, FTP, and more.
 					</DialogDescription>
 				</DialogHeader>
 				{(isError || isErrorConnection) && (
@@ -239,20 +301,21 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 									<FormItem>
 										<FormLabel>Name</FormLabel>
 										<FormControl>
-											<Input placeholder={"S3 Bucket"} {...field} />
+											<Input placeholder={"My Backup Destination"} {...field} />
 										</FormControl>
 										<FormMessage />
 									</FormItem>
 								);
 							}}
 						/>
+
 						<FormField
 							control={form.control}
-							name="provider"
+							name="destinationType"
 							render={({ field }) => {
 								return (
 									<FormItem>
-										<FormLabel>Provider</FormLabel>
+										<FormLabel>Destination Type</FormLabel>
 										<FormControl>
 											<Select
 												onValueChange={field.onChange}
@@ -261,16 +324,13 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 											>
 												<FormControl>
 													<SelectTrigger>
-														<SelectValue placeholder="Select a S3 Provider" />
+														<SelectValue placeholder="Select a destination type" />
 													</SelectTrigger>
 												</FormControl>
 												<SelectContent>
-													{S3_PROVIDERS.map((s3Provider) => (
-														<SelectItem
-															key={s3Provider.key}
-															value={s3Provider.key}
-														>
-															{s3Provider.name}
+													{DESTINATION_TYPES.map((dt) => (
+														<SelectItem key={dt.key} value={dt.key}>
+															{dt.name}
 														</SelectItem>
 													))}
 												</SelectContent>
@@ -282,82 +342,302 @@ export const HandleDestinations = ({ destinationId }: Props) => {
 							}}
 						/>
 
-						<FormField
-							control={form.control}
-							name="accessKeyId"
-							render={({ field }) => {
-								return (
-									<FormItem>
-										<FormLabel>Access Key Id</FormLabel>
-										<FormControl>
-											<Input placeholder={"xcas41dasde"} {...field} />
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								);
-							}}
-						/>
-						<FormField
-							control={form.control}
-							name="secretAccessKey"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Secret Access Key</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"asd123asdasw"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="bucket"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Bucket</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"dokploy-bucket"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="region"
-							render={({ field }) => (
-								<FormItem>
-									<div className="space-y-0.5">
-										<FormLabel>Region</FormLabel>
-									</div>
-									<FormControl>
-										<Input placeholder={"us-east-1"} {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-						<FormField
-							control={form.control}
-							name="endpoint"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Endpoint</FormLabel>
-									<FormControl>
-										<Input
-											placeholder={"https://us.bucket.aws/s3"}
-											{...field}
-										/>
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
+						{/* S3 Fields */}
+						{destinationType === "s3" && (
+							<>
+								<FormField
+									control={form.control}
+									name="provider"
+									render={({ field }) => {
+										return (
+											<FormItem>
+												<FormLabel>Provider</FormLabel>
+												<FormControl>
+													<Select
+														onValueChange={field.onChange}
+														defaultValue={field.value}
+														value={field.value}
+													>
+														<FormControl>
+															<SelectTrigger>
+																<SelectValue placeholder="Select a S3 Provider" />
+															</SelectTrigger>
+														</FormControl>
+														<SelectContent>
+															{S3_PROVIDERS.map((s3Provider) => (
+																<SelectItem
+																	key={s3Provider.key}
+																	value={s3Provider.key}
+																>
+																	{s3Provider.name}
+																</SelectItem>
+															))}
+														</SelectContent>
+													</Select>
+												</FormControl>
+												<FormMessage />
+											</FormItem>
+										);
+									}}
+								/>
+
+								<FormField
+									control={form.control}
+									name="accessKeyId"
+									render={({ field }) => {
+										return (
+											<FormItem>
+												<FormLabel>Access Key Id</FormLabel>
+												<FormControl>
+													<Input placeholder={"xcas41dasde"} {...field} />
+												</FormControl>
+												<FormMessage />
+											</FormItem>
+										);
+									}}
+								/>
+								<FormField
+									control={form.control}
+									name="secretAccessKey"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Secret Access Key</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"asd123asdasw"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="bucket"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Bucket</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"dokploy-bucket"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="region"
+									render={({ field }) => (
+										<FormItem>
+											<div className="space-y-0.5">
+												<FormLabel>Region</FormLabel>
+											</div>
+											<FormControl>
+												<Input placeholder={"us-east-1"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="endpoint"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Endpoint</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"https://us.bucket.aws/s3"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
+
+						{/* SFTP Fields */}
+						{destinationType === "sftp" && (
+							<>
+								<FormField
+									control={form.control}
+									name="sftpHost"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Host</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"backup.example.com"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="sftpPort"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Port</FormLabel>
+											<FormControl>
+												<Input
+													type="number"
+													placeholder={"22"}
+													{...field}
+													onChange={(e) =>
+														field.onChange(
+															e.target.value
+																? Number.parseInt(e.target.value)
+																: undefined,
+														)
+													}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="sftpUsername"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Username</FormLabel>
+											<FormControl>
+												<Input placeholder={"backupuser"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="sftpPassword"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Password (optional if using key)</FormLabel>
+											<FormControl>
+												<Input
+													type="password"
+													placeholder={"Leave empty for key-based auth"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="sftpKeyPath"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>
+												SSH Key Path (optional if using password)
+											</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"/root/.ssh/id_rsa"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="sftpRemotePath"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Remote Path</FormLabel>
+											<FormControl>
+												<Input placeholder={"/backups"} {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
+
+						{/* Rclone Custom Fields */}
+						{destinationType === "rclone" && (
+							<>
+								<FormField
+									control={form.control}
+									name="rcloneConfig"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Rclone Configuration</FormLabel>
+											<FormControl>
+												<Textarea
+													rows={8}
+													className="font-mono text-xs"
+													placeholder={`[myremote]\ntype = drive\nclient_id = xxx\nclient_secret = xxx\ntoken = {"access_token":"xxx"}`}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+											<p className="text-xs text-muted-foreground">
+												Paste your rclone config here. You can generate one
+												with <code>rclone config</code> on your machine, then
+												copy the content from <code>~/.config/rclone/rclone.conf</code>.
+												This supports Google Drive, OneDrive, Azure Blob, FTP,
+												and 50+ other providers.
+											</p>
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="rcloneRemoteName"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Remote Name</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"myremote"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+											<p className="text-xs text-muted-foreground">
+												The name inside the square brackets of your rclone
+												config (e.g., <code>[myremote]</code> means the name is{" "}
+												<code>myremote</code>).
+											</p>
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="rcloneRemotePath"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Remote Path</FormLabel>
+											<FormControl>
+												<Input
+													placeholder={"dokploy-backups"}
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+											<p className="text-xs text-muted-foreground">
+												The folder/path on the remote where backups will be
+												stored.
+											</p>
+										</FormItem>
+									)}
+								/>
+							</>
+						)}
 					</form>
 
 					<DialogFooter
diff --git a/apps/dokploy/components/dashboard/settings/destination/show-destinations.tsx b/apps/dokploy/components/dashboard/settings/destination/show-destinations.tsx
index f0ad39807c..d6576d1229 100644
--- a/apps/dokploy/components/dashboard/settings/destination/show-destinations.tsx
+++ b/apps/dokploy/components/dashboard/settings/destination/show-destinations.tsx
@@ -1,4 +1,4 @@
-import { Database, FolderUp, Loader2, Trash2 } from "lucide-react";
+import { Database, FolderUp, HardDrive, Loader2, Server, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 import { DialogAction } from "@/components/shared/dialog-action";
 import { Button } from "@/components/ui/button";
@@ -12,6 +12,30 @@ import {
 import { api } from "@/utils/api";
 import { HandleDestinations } from "./handle-destinations";
 
+const getDestinationTypeLabel = (type: string | null) => {
+	switch (type) {
+		case "sftp":
+			return "SFTP";
+		case "rclone":
+			return "Rclone";
+		case "s3":
+		default:
+			return "S3";
+	}
+};
+
+const getDestinationIcon = (type: string | null) => {
+	switch (type) {
+		case "sftp":
+			return <Server className="size-3.5 text-muted-foreground" />;
+		case "rclone":
+			return <HardDrive className="size-3.5 text-muted-foreground" />;
+		case "s3":
+		default:
+			return <Database className="size-3.5 text-muted-foreground" />;
+	}
+};
+
 export const ShowDestinations = () => {
 	const { data, isLoading, refetch } = api.destination.all.useQuery();
 	const { mutateAsync, isLoading: isRemoving } =
@@ -23,11 +47,11 @@ export const ShowDestinations = () => {
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
 							<Database className="size-6 text-muted-foreground self-center" />
-							S3 Destinations
+							Backup Destinations
 						</CardTitle>
 						<CardDescription>
-							Add your providers like AWS S3, Cloudflare R2, Wasabi,
-							DigitalOcean Spaces etc.
+							Add your providers like AWS S3, Cloudflare R2, SFTP servers,
+							Google Drive, OneDrive, and more via rclone.
 						</CardDescription>
 					</CardHeader>
 					<CardContent className="space-y-2 py-8 border-t">
@@ -57,9 +81,19 @@ export const ShowDestinations = () => {
 												>
 													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 														<div className="flex flex-col gap-1">
-															<span className="text-sm">
-																{index + 1}. {destination.name}
-															</span>
+															<div className="flex items-center gap-2">
+																{getDestinationIcon(
+																	destination.destinationType,
+																)}
+																<span className="text-sm">
+																	{index + 1}. {destination.name}
+																</span>
+																<span className="text-xs px-1.5 py-0.5 rounded-md bg-muted text-muted-foreground">
+																	{getDestinationTypeLabel(
+																		destination.destinationType,
+																	)}
+																</span>
+															</div>
 															<span className="text-xs text-muted-foreground">
 																Created at:{" "}
 																{new Date(
diff --git a/apps/dokploy/drizzle/0145_backup_destinations.sql b/apps/dokploy/drizzle/0145_backup_destinations.sql
new file mode 100644
index 0000000000..7cb9643104
--- /dev/null
+++ b/apps/dokploy/drizzle/0145_backup_destinations.sql
@@ -0,0 +1,23 @@
+-- Add destination type enum and new columns for SFTP and rclone backup destinations
+DO $$ BEGIN
+ CREATE TYPE "public"."destinationType" AS ENUM('s3', 'sftp', 'rclone');
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "destinationType" "destinationType" DEFAULT 's3' NOT NULL;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpHost" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpPort" integer;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpUsername" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpPassword" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpKeyPath" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "sftpRemotePath" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "rcloneConfig" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "rcloneRemoteName" text;--> statement-breakpoint
+ALTER TABLE "destination" ADD COLUMN IF NOT EXISTS "rcloneRemotePath" text;--> statement-breakpoint
+-- Set default values for existing S3 columns that may have been NOT NULL without defaults
+ALTER TABLE "destination" ALTER COLUMN "accessKey" SET DEFAULT '';--> statement-breakpoint
+ALTER TABLE "destination" ALTER COLUMN "secretAccessKey" SET DEFAULT '';--> statement-breakpoint
+ALTER TABLE "destination" ALTER COLUMN "bucket" SET DEFAULT '';--> statement-breakpoint
+ALTER TABLE "destination" ALTER COLUMN "region" SET DEFAULT '';--> statement-breakpoint
+ALTER TABLE "destination" ALTER COLUMN "endpoint" SET DEFAULT '';
diff --git a/apps/dokploy/drizzle/meta/_journal.json b/apps/dokploy/drizzle/meta/_journal.json
index 9b03c9d279..080827e923 100644
--- a/apps/dokploy/drizzle/meta/_journal.json
+++ b/apps/dokploy/drizzle/meta/_journal.json
@@ -1016,6 +1016,13 @@
       "when": 1771297084611,
       "tag": "0144_odd_gunslinger",
       "breakpoints": true
+    },
+    {
+      "idx": 145,
+      "version": "7",
+      "when": 1771300000000,
+      "tag": "0145_backup_destinations",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/apps/dokploy/server/api/routers/destination.ts b/apps/dokploy/server/api/routers/destination.ts
index d7cbf53d55..1adbb8a459 100644
--- a/apps/dokploy/server/api/routers/destination.ts
+++ b/apps/dokploy/server/api/routers/destination.ts
@@ -3,6 +3,9 @@ import {
 	execAsync,
 	execAsyncRemote,
 	findDestinationById,
+	getRcloneConfigSetup,
+	getRcloneFlags,
+	shellEscape,
 	IS_CLOUD,
 	removeDestinationById,
 	updateDestinationById,
@@ -43,26 +46,73 @@ export const destinationRouter = createTRPCRouter({
 	testConnection: adminProcedure
 		.input(apiCreateDestination)
 		.mutation(async ({ input }) => {
-			const { secretAccessKey, bucket, region, endpoint, accessKey, provider } =
-				input;
+			const destType = input.destinationType || "s3";
+
 			try {
-				const rcloneFlags = [
-					`--s3-access-key-id="${accessKey}"`,
-					`--s3-secret-access-key="${secretAccessKey}"`,
-					`--s3-region="${region}"`,
-					`--s3-endpoint="${endpoint}"`,
-					"--s3-no-check-bucket",
-					"--s3-force-path-style",
-					"--retries 1",
-					"--low-level-retries 1",
-					"--timeout 10s",
-					"--contimeout 5s",
-				];
-				if (provider) {
-					rcloneFlags.unshift(`--s3-provider="${provider}"`);
+				let rcloneCommand: string;
+
+				if (destType === "s3") {
+					const {
+						secretAccessKey,
+						bucket,
+						region,
+						endpoint,
+						accessKey,
+						provider,
+					} = input;
+					const rcloneFlags = [
+						`--s3-access-key-id=${shellEscape(accessKey || "")}`,
+						`--s3-secret-access-key=${shellEscape(secretAccessKey || "")}`,
+						`--s3-region=${shellEscape(region || "")}`,
+						`--s3-endpoint=${shellEscape(endpoint || "")}`,
+						"--s3-no-check-bucket",
+						"--s3-force-path-style",
+						"--retries 1",
+						"--low-level-retries 1",
+						"--timeout 10s",
+						"--contimeout 5s",
+					];
+					if (provider) {
+						rcloneFlags.unshift(`--s3-provider=${shellEscape(provider)}`);
+					}
+					const rcloneDestination = `:s3:${bucket}`;  // bucket is already validated by schema
+					rcloneCommand = `rclone ls ${rcloneFlags.join(" ")} ${shellEscape(rcloneDestination)}`;
+				} else if (destType === "sftp") {
+					const { sftpHost, sftpPort, sftpUsername, sftpPassword, sftpKeyPath, sftpRemotePath } = input;
+					const rcloneFlags = [
+						`--sftp-host=${shellEscape(sftpHost || "")}`,
+						`--sftp-user=${shellEscape(sftpUsername || "")}`,
+						"--retries 1",
+						"--low-level-retries 1",
+						"--timeout 10s",
+						"--contimeout 5s",
+					];
+					if (sftpPort) {
+						rcloneFlags.push(`--sftp-port=${shellEscape(String(sftpPort))}`);
+					}
+					if (sftpPassword) {
+						rcloneFlags.push(`--sftp-pass=$(rclone obscure ${shellEscape(sftpPassword)})`);
+					}
+					if (sftpKeyPath) {
+						rcloneFlags.push(`--sftp-key-file=${shellEscape(sftpKeyPath)}`);
+					}
+					const remotePath = (sftpRemotePath || "/").replace(/\/+$/, "");
+					rcloneCommand = `rclone ls ${rcloneFlags.join(" ")} ${shellEscape(`:sftp:${remotePath}`)}`;
+				} else if (destType === "rclone") {
+					const { rcloneConfig, rcloneRemoteName, rcloneRemotePath } = input;
+					const escapedConfig = (rcloneConfig || "").replace(/'/g, "'\\''");
+					const configSetup = rcloneConfig
+						? `RCLONE_CONFIG_FILE=$(mktemp /tmp/rclone-config-XXXXXX.conf) && cat > "$RCLONE_CONFIG_FILE" << 'RCLONE_EOF'\n${escapedConfig}\nRCLONE_EOF\nexport RCLONE_CONFIG="$RCLONE_CONFIG_FILE" && trap 'rm -f "$RCLONE_CONFIG_FILE"' EXIT && `
+						: "";
+					const remoteName = rcloneRemoteName || "remote";
+					const remotePath = (rcloneRemotePath || "").replace(/\/+$/, "");
+					rcloneCommand = `${configSetup}rclone ls --retries 1 --low-level-retries 1 --timeout 10s --contimeout 5s ${shellEscape(`${remoteName}:${remotePath}`)}`;
+				} else {
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message: `Unknown destination type: ${destType}`,
+					});
 				}
-				const rcloneDestination = `:s3:${bucket}`;
-				const rcloneCommand = `rclone ls ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 				if (IS_CLOUD && !input.serverId) {
 					throw new TRPCError({
@@ -82,7 +132,7 @@ export const destinationRouter = createTRPCRouter({
 					message:
 						error instanceof Error
 							? error?.message
-							: "Error connecting to bucket",
+							: "Error connecting to destination",
 					cause: error,
 				});
 			}
diff --git a/packages/server/src/db/schema/destination.ts b/packages/server/src/db/schema/destination.ts
index d1442a9a95..79536fd153 100644
--- a/packages/server/src/db/schema/destination.ts
+++ b/packages/server/src/db/schema/destination.ts
@@ -1,23 +1,44 @@
 import { relations } from "drizzle-orm";
-import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { pgEnum, pgTable, text, integer, timestamp } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
 import { backups } from "./backups";
 
+export const destinationTypeEnum = pgEnum("destinationType", [
+	"s3",
+	"sftp",
+	"rclone",
+]);
+
 export const destinations = pgTable("destination", {
 	destinationId: text("destinationId")
 		.notNull()
 		.primaryKey()
 		.$defaultFn(() => nanoid()),
 	name: text("name").notNull(),
+	destinationType: destinationTypeEnum("destinationType")
+		.notNull()
+		.default("s3"),
+	// S3 fields (used when destinationType = "s3")
 	provider: text("provider"),
-	accessKey: text("accessKey").notNull(),
-	secretAccessKey: text("secretAccessKey").notNull(),
-	bucket: text("bucket").notNull(),
-	region: text("region").notNull(),
-	endpoint: text("endpoint").notNull(),
+	accessKey: text("accessKey").notNull().default(""),
+	secretAccessKey: text("secretAccessKey").notNull().default(""),
+	bucket: text("bucket").notNull().default(""),
+	region: text("region").notNull().default(""),
+	endpoint: text("endpoint").notNull().default(""),
+	// SFTP fields (used when destinationType = "sftp")
+	sftpHost: text("sftpHost"),
+	sftpPort: integer("sftpPort"),
+	sftpUsername: text("sftpUsername"),
+	sftpPassword: text("sftpPassword"),
+	sftpKeyPath: text("sftpKeyPath"),
+	sftpRemotePath: text("sftpRemotePath"),
+	// Generic rclone config (used when destinationType = "rclone")
+	rcloneConfig: text("rcloneConfig"),
+	rcloneRemoteName: text("rcloneRemoteName"),
+	rcloneRemotePath: text("rcloneRemotePath"),
 	organizationId: text("organizationId")
 		.notNull()
 		.references(() => organization.id, { onDelete: "cascade" }),
@@ -38,23 +59,43 @@ export const destinationsRelations = relations(
 const createSchema = createInsertSchema(destinations, {
 	destinationId: z.string(),
 	name: z.string().min(1),
-	provider: z.string(),
-	accessKey: z.string(),
-	bucket: z.string(),
-	endpoint: z.string(),
-	secretAccessKey: z.string(),
-	region: z.string(),
+	destinationType: z.enum(["s3", "sftp", "rclone"]).default("s3"),
+	provider: z.string().optional(),
+	accessKey: z.string().optional(),
+	bucket: z.string().optional(),
+	endpoint: z.string().optional(),
+	secretAccessKey: z.string().optional(),
+	region: z.string().optional(),
+	sftpHost: z.string().optional(),
+	sftpPort: z.number().optional(),
+	sftpUsername: z.string().optional(),
+	sftpPassword: z.string().optional(),
+	sftpKeyPath: z.string().optional(),
+	sftpRemotePath: z.string().optional(),
+	rcloneConfig: z.string().optional(),
+	rcloneRemoteName: z.string().optional(),
+	rcloneRemotePath: z.string().optional(),
 });
 
 export const apiCreateDestination = createSchema
 	.pick({
 		name: true,
+		destinationType: true,
 		provider: true,
 		accessKey: true,
 		bucket: true,
 		region: true,
 		endpoint: true,
 		secretAccessKey: true,
+		sftpHost: true,
+		sftpPort: true,
+		sftpUsername: true,
+		sftpPassword: true,
+		sftpKeyPath: true,
+		sftpRemotePath: true,
+		rcloneConfig: true,
+		rcloneRemoteName: true,
+		rcloneRemotePath: true,
 	})
 	.required()
 	.extend({
@@ -76,6 +117,7 @@ export const apiRemoveDestination = createSchema
 export const apiUpdateDestination = createSchema
 	.pick({
 		name: true,
+		destinationType: true,
 		accessKey: true,
 		bucket: true,
 		region: true,
@@ -83,6 +125,15 @@ export const apiUpdateDestination = createSchema
 		secretAccessKey: true,
 		destinationId: true,
 		provider: true,
+		sftpHost: true,
+		sftpPort: true,
+		sftpUsername: true,
+		sftpPassword: true,
+		sftpKeyPath: true,
+		sftpRemotePath: true,
+		rcloneConfig: true,
+		rcloneRemoteName: true,
+		rcloneRemotePath: true,
 	})
 	.required()
 	.extend({
diff --git a/packages/server/src/utils/backups/compose.ts b/packages/server/src/utils/backups/compose.ts
index 1963f2c910..eb002776fd 100644
--- a/packages/server/src/utils/backups/compose.ts
+++ b/packages/server/src/utils/backups/compose.ts
@@ -8,7 +8,13 @@ import { findEnvironmentById } from "@dokploy/server/services/environment";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getBackupCommand,
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runComposeBackup = async (
 	compose: Compose,
@@ -28,9 +34,14 @@ export const runComposeBackup = async (
 	});
 
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const rcloneDestination = getRcloneDestinationPath(
+			destination,
+			bucketDestination,
+		);
+
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
diff --git a/packages/server/src/utils/backups/index.ts b/packages/server/src/utils/backups/index.ts
index 8da8f116a5..04383a4f43 100644
--- a/packages/server/src/utils/backups/index.ts
+++ b/packages/server/src/utils/backups/index.ts
@@ -1,4 +1,3 @@
-import path from "node:path";
 import { CLEANUP_CRON_JOB } from "@dokploy/server/constants";
 import { member } from "@dokploy/server/db/schema";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
@@ -11,7 +10,12 @@ import { startLogCleanup } from "../access-log/handler";
 import { cleanupAll } from "../docker/utils";
 import { sendDockerCleanupNotifications } from "../notifications/docker-cleanup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials, scheduleBackup } from "./utils";
+import {
+	getRcloneBasePath,
+	getRcloneConfigSetup,
+	getRcloneFlags,
+	scheduleBackup,
+} from "./utils";
 
 export const initCronJobs = async () => {
 	console.log("Setting up cron jobs....");
@@ -104,14 +108,15 @@ export const keepLatestNBackups = async (
 	if (!backup.keepLatestCount) return;
 
 	try {
-		const rcloneFlags = getS3Credentials(backup.destination);
-		const backupFilesPath = path.join(
-			`:s3:${backup.destination.bucket}`,
+		const rcloneFlags = getRcloneFlags(backup.destination);
+		const configSetup = getRcloneConfigSetup(backup.destination);
+		const backupFilesPath = getRcloneBasePath(
+			backup.destination,
 			backup.prefix,
 		);
 
 		// --include "*.sql.gz" or "*.zip" ensures nothing else other than the dokploy backup files are touched by rclone
-		const rcloneList = `rclone lsf ${rcloneFlags.join(" ")} --include "*${backup.databaseType === "web-server" ? ".zip" : ".sql.gz"}" ${backupFilesPath}`;
+		const rcloneList = `${configSetup}rclone lsf ${rcloneFlags.join(" ")} --include "*${backup.databaseType === "web-server" ? ".zip" : ".sql.gz"}" ${backupFilesPath}`;
 		// when we pipe the above command with this one, we only get the list of files we want to delete
 		const sortAndPickUnwantedBackups = `sort -r | tail -n +$((${backup.keepLatestCount}+1)) | xargs -I{}`;
 		// this command deletes the files
diff --git a/packages/server/src/utils/backups/mariadb.ts b/packages/server/src/utils/backups/mariadb.ts
index 56cb1a9aaf..409b440951 100644
--- a/packages/server/src/utils/backups/mariadb.ts
+++ b/packages/server/src/utils/backups/mariadb.ts
@@ -8,7 +8,13 @@ import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getBackupCommand,
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runMariadbBackup = async (
 	mariadb: Mariadb,
@@ -27,9 +33,14 @@ export const runMariadbBackup = async (
 		description: "MariaDB Backup",
 	});
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const rcloneDestination = getRcloneDestinationPath(
+			destination,
+			bucketDestination,
+		);
+
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
diff --git a/packages/server/src/utils/backups/mongo.ts b/packages/server/src/utils/backups/mongo.ts
index 2071478a0b..6cfa0d6bbf 100644
--- a/packages/server/src/utils/backups/mongo.ts
+++ b/packages/server/src/utils/backups/mongo.ts
@@ -8,7 +8,13 @@ import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getBackupCommand,
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 	const { environmentId, name } = mongo;
@@ -24,9 +30,14 @@ export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 		description: "MongoDB Backup",
 	});
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const rcloneDestination = getRcloneDestinationPath(
+			destination,
+			bucketDestination,
+		);
+
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
diff --git a/packages/server/src/utils/backups/mysql.ts b/packages/server/src/utils/backups/mysql.ts
index d131090fa3..58040aef40 100644
--- a/packages/server/src/utils/backups/mysql.ts
+++ b/packages/server/src/utils/backups/mysql.ts
@@ -8,7 +8,13 @@ import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getBackupCommand,
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	const { environmentId, name } = mysql;
@@ -25,10 +31,14 @@ export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	});
 
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const rcloneDestination = getRcloneDestinationPath(
+			destination,
+			bucketDestination,
+		);
 
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
diff --git a/packages/server/src/utils/backups/postgres.ts b/packages/server/src/utils/backups/postgres.ts
index 9241f2103a..7dcc648e15 100644
--- a/packages/server/src/utils/backups/postgres.ts
+++ b/packages/server/src/utils/backups/postgres.ts
@@ -8,7 +8,13 @@ import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getBackupCommand,
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runPostgresBackup = async (
 	postgres: Postgres,
@@ -28,10 +34,14 @@ export const runPostgresBackup = async (
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
 	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const rcloneDestination = getRcloneDestinationPath(
+			destination,
+			bucketDestination,
+		);
 
-		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
 
 		const backupCommand = getBackupCommand(
 			backup,
diff --git a/packages/server/src/utils/backups/utils.ts b/packages/server/src/utils/backups/utils.ts
index f30577a53b..d7b0314677 100644
--- a/packages/server/src/utils/backups/utils.ts
+++ b/packages/server/src/utils/backups/utils.ts
@@ -10,6 +10,29 @@ import { runMySqlBackup } from "./mysql";
 import { runPostgresBackup } from "./postgres";
 import { runWebServerBackup } from "./web-server";
 
+
+/**
+ * Escape a string for safe use in shell commands.
+ * Wraps the value in single quotes and escapes any embedded single quotes.
+ */
+export const shellEscape = (str: string): string => {
+	return `'${str.replace(/'/g, "'\\''")}'`;
+};
+
+/**
+ * Escape a string for safe embedding inside double-quoted shell strings.
+ * Prevents interpretation of $, `, \, ", and ! characters.
+ */
+const escapeForDoubleQuotes = (str: string): string => {
+	return str
+		.replace(/\\/g, "\\\\")
+		.replace(/\$/g, "\\$")
+		.replace(/`/g, "\\`")
+		.replace(/"/g, '\\"')
+		.replace(/!/g, "\\!");
+};
+
+
 export const scheduleBackup = (backup: BackupSchedule) => {
 	const {
 		schedule,
@@ -58,25 +81,164 @@ export const normalizeS3Path = (prefix: string) => {
 	return normalizedPrefix ? `${normalizedPrefix}/` : "";
 };
 
+/**
+ * Get rclone flags for S3-compatible destinations.
+ * Kept as getS3Credentials for backward compatibility.
+ */
 export const getS3Credentials = (destination: Destination) => {
 	const { accessKey, secretAccessKey, region, endpoint, provider } =
 		destination;
 	const rcloneFlags = [
-		`--s3-access-key-id="${accessKey}"`,
-		`--s3-secret-access-key="${secretAccessKey}"`,
-		`--s3-region="${region}"`,
-		`--s3-endpoint="${endpoint}"`,
+		`--s3-access-key-id=${shellEscape(accessKey)}`,
+		`--s3-secret-access-key=${shellEscape(secretAccessKey)}`,
+		`--s3-region=${shellEscape(region)}`,
+		`--s3-endpoint=${shellEscape(endpoint)}`,
 		"--s3-no-check-bucket",
 		"--s3-force-path-style",
 	];
 
 	if (provider) {
-		rcloneFlags.unshift(`--s3-provider="${provider}"`);
+		rcloneFlags.unshift(`--s3-provider=${shellEscape(provider)}`);
+	}
+
+	return rcloneFlags;
+};
+
+/**
+ * Get rclone flags for SFTP destinations.
+ */
+export const getSftpCredentials = (destination: Destination) => {
+	const { sftpHost, sftpPort, sftpUsername, sftpPassword, sftpKeyPath } =
+		destination;
+	const rcloneFlags = [
+		`--sftp-host=${shellEscape(sftpHost || "")}`,
+		`--sftp-user=${shellEscape(sftpUsername || "")}`,
+	];
+
+	if (sftpPort) {
+		rcloneFlags.push(`--sftp-port=${shellEscape(String(sftpPort))}`);
+	}
+
+	if (sftpPassword) {
+		const obscuredPass = `$(rclone obscure ${shellEscape(sftpPassword)})`;
+		rcloneFlags.push(`--sftp-pass=${obscuredPass}`);
+	}
+
+	if (sftpKeyPath) {
+		rcloneFlags.push(`--sftp-key-file=${shellEscape(sftpKeyPath)}`);
 	}
 
 	return rcloneFlags;
 };
 
+/**
+ * Get rclone flags based on destination type.
+ * Unified function that handles all destination types.
+ */
+export const getRcloneFlags = (destination: Destination): string[] => {
+	const destType = destination.destinationType || "s3";
+
+	switch (destType) {
+		case "s3":
+			return getS3Credentials(destination);
+		case "sftp":
+			return getSftpCredentials(destination);
+		case "rclone":
+			// For generic rclone config, no additional flags needed
+			// as the config file will be used
+			return [];
+		default:
+			return getS3Credentials(destination);
+	}
+};
+
+/**
+ * Get the rclone remote path prefix based on destination type.
+ * For S3: `:s3:bucket/path`
+ * For SFTP: `:sftp:remotePath/path`
+ * For rclone: `remoteName:remotePath/path`
+ */
+export const getRcloneDestinationPath = (
+	destination: Destination,
+	subPath: string,
+): string => {
+	const destType = destination.destinationType || "s3";
+	switch (destType) {
+		case "s3":
+			return `:s3:${escapeForDoubleQuotes(destination.bucket)}/${escapeForDoubleQuotes(subPath)}`;
+		case "sftp": {
+			const remotePath = (destination.sftpRemotePath || "").replace(
+				/\/+$/,
+				"",
+			);
+			return `:sftp:${escapeForDoubleQuotes(remotePath)}/${escapeForDoubleQuotes(subPath)}`;
+		}
+		case "rclone": {
+			const remoteName = destination.rcloneRemoteName || "remote";
+			const remotePath = (destination.rcloneRemotePath || "").replace(
+				/\/+$/,
+				"",
+			);
+			return `${escapeForDoubleQuotes(remoteName)}:${escapeForDoubleQuotes(remotePath)}/${escapeForDoubleQuotes(subPath)}`;
+		}
+		default:
+			return `:s3:${escapeForDoubleQuotes(destination.bucket)}/${escapeForDoubleQuotes(subPath)}`;
+	}
+};
+
+/**
+ * Get the rclone base path for listing/deleting files (bucket or remote path).
+ */
+export const getRcloneBasePath = (
+	destination: Destination,
+	prefix: string,
+): string => {
+	const destType = destination.destinationType || "s3";
+
+	switch (destType) {
+		case "s3":
+			return `:s3:${escapeForDoubleQuotes(destination.bucket)}/${escapeForDoubleQuotes(prefix)}`;
+		case "sftp": {
+			const remotePath = (destination.sftpRemotePath || "").replace(
+				/\/+$/,
+				"",
+			);
+			return `:sftp:${escapeForDoubleQuotes(remotePath)}/${escapeForDoubleQuotes(prefix)}`;
+		}
+		case "rclone": {
+			const remoteName = destination.rcloneRemoteName || "remote";
+			const remotePath = (destination.rcloneRemotePath || "").replace(
+				/\/+$/,
+				"",
+			);
+			return `${escapeForDoubleQuotes(remoteName)}:${escapeForDoubleQuotes(remotePath)}/${escapeForDoubleQuotes(prefix)}`;
+		}
+		default:
+			return `:s3:${escapeForDoubleQuotes(destination.bucket)}/${escapeForDoubleQuotes(prefix)}`;
+	}
+};
+
+/**
+ * Generate the rclone config file content and env setup for rclone destinations.
+ * Returns the shell commands to create the config file.
+ */
+export const getRcloneConfigSetup = (destination: Destination): string => {
+	if (destination.destinationType !== "rclone" || !destination.rcloneConfig) {
+		return "";
+	}
+
+	const configContent = destination.rcloneConfig.replace(/'/g, "'\\''");
+	return `
+RCLONE_CONFIG_FILE=$(mktemp /tmp/rclone-config-XXXXXX.conf)
+cat > "$RCLONE_CONFIG_FILE" << 'RCLONE_EOF'
+${configContent}
+RCLONE_EOF
+export RCLONE_CONFIG="$RCLONE_CONFIG_FILE"
+_cleanup_rclone_config() { rm -f "$RCLONE_CONFIG_FILE"; }
+trap _cleanup_rclone_config EXIT
+`;
+};
+
 export const getPostgresBackupCommand = (
 	database: string,
 	databaseUser: string,
@@ -223,6 +385,13 @@ export const getBackupCommand = (
 ) => {
 	const containerSearch = getContainerSearchCommand(backup);
 	const backupCommand = generateBackupCommand(backup);
+	const destinationType = backup.destination.destinationType || "s3";
+	const uploadLabel =
+		destinationType === "s3"
+			? "S3"
+			: destinationType === "sftp"
+				? "SFTP"
+				: "remote";
 
 	logger.info(
 		{
@@ -234,8 +403,11 @@ export const getBackupCommand = (
 		`Executing backup command: ${backup.databaseType} ${backup.backupType}`,
 	);
 
+	const configSetup = getRcloneConfigSetup(backup.destination);
+
 	return `
 	set -eo pipefail;
+	${configSetup}
 	echo "[$(date)] Starting backup process..." >> ${logPath};
 	echo "[$(date)] Executing backup command..." >> ${logPath};
 	CONTAINER_ID=$(${containerSearch})
@@ -255,16 +427,16 @@ export const getBackupCommand = (
 	}
 
 	echo "[$(date)] ✅ backup completed successfully" >> ${logPath};
-	echo "[$(date)] Starting upload to S3..." >> ${logPath};
+	echo "[$(date)] Starting upload to ${uploadLabel}..." >> ${logPath};
 
 	# Run the upload command and capture the exit status
 	UPLOAD_OUTPUT=$(${backupCommand} | ${rcloneCommand} 2>&1 >/dev/null) || {
-		echo "[$(date)] ❌ Error: Upload to S3 failed" >> ${logPath};
+		echo "[$(date)] ❌ Error: Upload to ${uploadLabel} failed" >> ${logPath};
 		echo "Error: $UPLOAD_OUTPUT" >> ${logPath};
 		exit 1;
 	}
 
-	echo "[$(date)] ✅ Upload to S3 completed successfully" >> ${logPath};
+	echo "[$(date)] ✅ Upload to ${uploadLabel} completed successfully" >> ${logPath};
 	echo "Backup done ✅" >> ${logPath};
 	`;
 };
diff --git a/packages/server/src/utils/backups/web-server.ts b/packages/server/src/utils/backups/web-server.ts
index 4d13ae31ae..6d1b057b88 100644
--- a/packages/server/src/utils/backups/web-server.ts
+++ b/packages/server/src/utils/backups/web-server.ts
@@ -10,7 +10,12 @@ import {
 } from "@dokploy/server/services/deployment";
 import { findDestinationById } from "@dokploy/server/services/destination";
 import { execAsync } from "../process/execAsync";
-import { getS3Credentials, normalizeS3Path } from "./utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "./utils";
 
 export const runWebServerBackup = async (backup: BackupSchedule) => {
 	if (IS_CLOUD) {
@@ -26,12 +31,15 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 
 	try {
 		const destination = await findDestinationById(backup.destinationId);
-		const rcloneFlags = getS3Credentials(destination);
+		const rcloneFlags = getRcloneFlags(destination);
 		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
 		const { BASE_PATH } = paths();
 		const tempDir = await mkdtemp(join(tmpdir(), "dokploy-backup-"));
 		const backupFileName = `webserver-backup-${timestamp}.zip`;
-		const s3Path = `:s3:${destination.bucket}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
+		const s3Path = getRcloneDestinationPath(
+			destination,
+			`${normalizeS3Path(backup.prefix)}${backupFileName}`,
+		);
 
 		try {
 			await execAsync(`mkdir -p ${tempDir}/filesystem`);
@@ -42,7 +50,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 			);
 
 			if (!containerId) {
-				writeStream.write("Dokploy postgres container not found❌\n");
+				writeStream.write("Dokploy postgres container not found\n");
 				writeStream.end();
 				throw new Error("Dokploy postgres container not found");
 			}
@@ -79,10 +87,11 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 
 			writeStream.write("Zipped database and filesystem\n");
 
-			const uploadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${tempDir}/${backupFileName}" "${s3Path}"`;
-			writeStream.write("Running command to upload backup to S3\n");
+			const configSetup = getRcloneConfigSetup(destination);
+			const uploadCommand = `${configSetup}rclone copyto ${rcloneFlags.join(" ")} "${tempDir}/${backupFileName}" "${s3Path}"`;
+			writeStream.write("Running command to upload backup\n");
 			await execAsync(uploadCommand);
-			writeStream.write("Uploaded backup to S3 ✅\n");
+			writeStream.write("Uploaded backup successfully\n");
 			writeStream.end();
 			await updateDeploymentStatus(deployment.deploymentId, "done");
 			return true;
@@ -95,7 +104,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 		}
 	} catch (error) {
 		console.error("Backup error:", error);
-		writeStream.write("Backup error❌\n");
+		writeStream.write("Backup error\n");
 		writeStream.write(
 			error instanceof Error ? error.message : "Unknown error\n",
 		);
diff --git a/packages/server/src/utils/restore/compose.ts b/packages/server/src/utils/restore/compose.ts
index d55b12fd8b..ccc644a8c5 100644
--- a/packages/server/src/utils/restore/compose.ts
+++ b/packages/server/src/utils/restore/compose.ts
@@ -2,7 +2,11 @@ import type { apiRestoreBackup } from "@dokploy/server/db/schema";
 import type { Compose } from "@dokploy/server/services/compose";
 import type { Destination } from "@dokploy/server/services/destination";
 import type { z } from "zod";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getRestoreCommand } from "./utils";
 
@@ -23,13 +27,17 @@ export const restoreComposeBackup = async (
 		}
 		const { serverId, appName, composeType } = compose;
 
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
-		let rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(
+			destination,
+			backupInput.backupFile,
+		);
+
+		const configSetup = getRcloneConfigSetup(destination);
+		let rcloneCommand = `${configSetup}rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
 
 		if (backupInput.metadata?.mongo) {
-			rcloneCommand = `rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
+			rcloneCommand = `${configSetup}rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
 		}
 
 		let credentials: DatabaseCredentials;
diff --git a/packages/server/src/utils/restore/mariadb.ts b/packages/server/src/utils/restore/mariadb.ts
index ffbceba765..a4e9470d62 100644
--- a/packages/server/src/utils/restore/mariadb.ts
+++ b/packages/server/src/utils/restore/mariadb.ts
@@ -2,7 +2,11 @@ import type { apiRestoreBackup } from "@dokploy/server/db/schema";
 import type { Destination } from "@dokploy/server/services/destination";
 import type { Mariadb } from "@dokploy/server/services/mariadb";
 import type { z } from "zod";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getRestoreCommand } from "./utils";
 
@@ -15,11 +19,14 @@ export const restoreMariadbBackup = async (
 	try {
 		const { appName, serverId, databaseUser, databasePassword } = mariadb;
 
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(
+			destination,
+			backupInput.backupFile,
+		);
 
-		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
 
 		const command = getRestoreCommand({
 			appName,
diff --git a/packages/server/src/utils/restore/mongo.ts b/packages/server/src/utils/restore/mongo.ts
index 4329a49857..c6ff7bbf0e 100644
--- a/packages/server/src/utils/restore/mongo.ts
+++ b/packages/server/src/utils/restore/mongo.ts
@@ -2,7 +2,11 @@ import type { apiRestoreBackup } from "@dokploy/server/db/schema";
 import type { Destination } from "@dokploy/server/services/destination";
 import type { Mongo } from "@dokploy/server/services/mongo";
 import type { z } from "zod";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getRestoreCommand } from "./utils";
 
@@ -15,10 +19,14 @@ export const restoreMongoBackup = async (
 	try {
 		const { appName, databasePassword, databaseUser, serverId } = mongo;
 
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
-		const rcloneCommand = `rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(
+			destination,
+			backupInput.backupFile,
+		);
+
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
 
 		const command = getRestoreCommand({
 			appName,
diff --git a/packages/server/src/utils/restore/mysql.ts b/packages/server/src/utils/restore/mysql.ts
index f5187242cf..7e2e04da53 100644
--- a/packages/server/src/utils/restore/mysql.ts
+++ b/packages/server/src/utils/restore/mysql.ts
@@ -2,7 +2,11 @@ import type { apiRestoreBackup } from "@dokploy/server/db/schema";
 import type { Destination } from "@dokploy/server/services/destination";
 import type { MySql } from "@dokploy/server/services/mysql";
 import type { z } from "zod";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getRestoreCommand } from "./utils";
 
@@ -15,11 +19,14 @@ export const restoreMySqlBackup = async (
 	try {
 		const { appName, databaseRootPassword, serverId } = mysql;
 
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(
+			destination,
+			backupInput.backupFile,
+		);
 
-		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
 
 		const command = getRestoreCommand({
 			appName,
diff --git a/packages/server/src/utils/restore/postgres.ts b/packages/server/src/utils/restore/postgres.ts
index 19f32989f0..b9adae035b 100644
--- a/packages/server/src/utils/restore/postgres.ts
+++ b/packages/server/src/utils/restore/postgres.ts
@@ -2,7 +2,11 @@ import type { apiRestoreBackup } from "@dokploy/server/db/schema";
 import type { Destination } from "@dokploy/server/services/destination";
 import type { Postgres } from "@dokploy/server/services/postgres";
 import type { z } from "zod";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getRestoreCommand } from "./utils";
 
@@ -15,12 +19,14 @@ export const restorePostgresBackup = async (
 	try {
 		const { appName, databaseUser, serverId } = postgres;
 
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-
-		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(
+			destination,
+			backupInput.backupFile,
+		);
 
-		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const rcloneCommand = `${configSetup}rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
 
 		emit("Starting restore...");
 		emit(`Backup path: ${backupPath}`);
diff --git a/packages/server/src/utils/restore/web-server.ts b/packages/server/src/utils/restore/web-server.ts
index 683a1898ae..960d9fdc91 100644
--- a/packages/server/src/utils/restore/web-server.ts
+++ b/packages/server/src/utils/restore/web-server.ts
@@ -3,7 +3,11 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { IS_CLOUD, paths } from "@dokploy/server/constants";
 import type { Destination } from "@dokploy/server/services/destination";
-import { getS3Credentials } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+} from "../backups/utils";
 import { execAsync } from "../process/execAsync";
 
 export const restoreWebServerBackup = async (
@@ -15,9 +19,8 @@ export const restoreWebServerBackup = async (
 		return;
 	}
 	try {
-		const rcloneFlags = getS3Credentials(destination);
-		const bucketPath = `:s3:${destination.bucket}`;
-		const backupPath = `${bucketPath}/${backupFile}`;
+		const rcloneFlags = getRcloneFlags(destination);
+		const backupPath = getRcloneDestinationPath(destination, backupFile);
 		const { BASE_PATH } = paths();
 
 		// Create a temporary directory outside of BASE_PATH
@@ -32,10 +35,11 @@ export const restoreWebServerBackup = async (
 			emit("Creating temporary directory...");
 			await execAsync(`mkdir -p ${tempDir}`);
 
-			// Download backup from S3
-			emit("Downloading backup from S3...");
+			// Download backup from destination
+			emit("Downloading backup from destination...");
+			const configSetup = getRcloneConfigSetup(destination);
 			await execAsync(
-				`rclone copyto ${rcloneFlags.join(" ")} "${backupPath}" "${tempDir}/${backupFile}"`,
+				`${configSetup}rclone copyto ${rcloneFlags.join(" ")} "${backupPath}" "${tempDir}/${backupFile}"`,
 			);
 
 			// List files before extraction
diff --git a/packages/server/src/utils/volume-backups/backup.ts b/packages/server/src/utils/volume-backups/backup.ts
index 3d229ef643..9b3078858f 100644
--- a/packages/server/src/utils/volume-backups/backup.ts
+++ b/packages/server/src/utils/volume-backups/backup.ts
@@ -2,7 +2,12 @@ import path from "node:path";
 import { paths } from "@dokploy/server/constants";
 import { findComposeById } from "@dokploy/server/services/compose";
 import type { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
-import { getS3Credentials, normalizeS3Path } from "../backups/utils";
+import {
+	getRcloneConfigSetup,
+	getRcloneDestinationPath,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "../backups/utils";
 
 export const backupVolume = async (
 	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
@@ -14,31 +19,35 @@ export const backupVolume = async (
 	const destination = volumeBackup.destination;
 	const backupFileName = `${volumeName}-${new Date().toISOString()}.tar`;
 	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
-	const rcloneFlags = getS3Credentials(volumeBackup.destination);
-	const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+	const rcloneFlags = getRcloneFlags(volumeBackup.destination);
+	const rcloneDestination = getRcloneDestinationPath(
+		destination,
+		bucketDestination,
+	);
 	const volumeBackupPath = path.join(VOLUME_BACKUPS_PATH, volumeBackup.appName);
 
-	const rcloneCommand = `rclone copyto ${rcloneFlags.join(" ")} "${volumeBackupPath}/${backupFileName}" "${rcloneDestination}"`;
+	const configSetup = getRcloneConfigSetup(destination);
+	const rcloneCommand = `${configSetup}rclone copyto ${rcloneFlags.join(" ")} "${volumeBackupPath}/${backupFileName}" "${rcloneDestination}"`;
 
 	const baseCommand = `
 	set -e
 	echo "Volume name: ${volumeName}"
 	echo "Backup file name: ${backupFileName}"
 	echo "Turning off volume backup: ${turnOff ? "Yes" : "No"}"
-	echo "Starting volume backup" 
+	echo "Starting volume backup"
 	echo "Dir: ${volumeBackupPath}"
     docker run --rm \
   -v ${volumeName}:/volume_data \
   -v ${volumeBackupPath}:/backup \
   ubuntu \
   bash -c "cd /volume_data && tar cvf /backup/${backupFileName} ."
-  echo "Volume backup done ✅"
-  echo "Starting upload to S3..."
+  echo "Volume backup done"
+  echo "Starting upload to destination..."
   ${rcloneCommand}
-  echo "Upload to S3 done ✅"
+  echo "Upload to destination done"
   echo "Cleaning up local backup file..."
   rm "${volumeBackupPath}/${backupFileName}"
-  echo "Local backup file cleaned up ✅"
+  echo "Local backup file cleaned up"
   `;
 
 	if (!turnOff) {
diff --git a/packages/server/src/utils/volume-backups/utils.ts b/packages/server/src/utils/volume-backups/utils.ts
index b508c6b882..6c91f815c4 100644
--- a/packages/server/src/utils/volume-backups/utils.ts
+++ b/packages/server/src/utils/volume-backups/utils.ts
@@ -10,7 +10,12 @@ import {
 	execAsyncRemote,
 } from "@dokploy/server/utils/process/execAsync";
 import { scheduledJobs, scheduleJob } from "node-schedule";
-import { getS3Credentials, normalizeS3Path } from "../backups/utils";
+import {
+	getRcloneBasePath,
+	getRcloneConfigSetup,
+	getRcloneFlags,
+	normalizeS3Path,
+} from "../backups/utils";
 import { sendVolumeBackupNotifications } from "../notifications/volume-backup";
 import { backupVolume } from "./backup";
 
@@ -80,13 +85,14 @@ const cleanupOldVolumeBackups = async (
 	if (!keepLatestCount) return;
 
 	try {
-		const rcloneFlags = getS3Credentials(destination);
+		const rcloneFlags = getRcloneFlags(destination);
 		const normalizedPrefix = normalizeS3Path(prefix);
-		const backupFilesPath = `:s3:${destination.bucket}/${normalizedPrefix}`;
-		const listCommand = `rclone lsf ${rcloneFlags.join(" ")} --include \"${volumeName}-*.tar\" :s3:${destination.bucket}/${normalizedPrefix}`;
+		const configSetup = getRcloneConfigSetup(destination);
+		const backupFilesPath = getRcloneBasePath(destination, normalizedPrefix);
+		const listCommand = `rclone lsf ${rcloneFlags.join(" ")} --include "${volumeName}-*.tar" ${backupFilesPath}`;
 		const sortAndPick = `sort -r | tail -n +$((${keepLatestCount}+1)) | xargs -I{}`;
 		const deleteCommand = `rclone delete ${rcloneFlags.join(" ")} ${backupFilesPath}{}`;
-		const fullCommand = `${listCommand} | ${sortAndPick} ${deleteCommand}`;
+		const fullCommand = `${configSetup}${listCommand} | ${sortAndPick} ${deleteCommand}`;
 
 		if (serverId) {
 			await execAsyncRemote(serverId, fullCommand);