How to Download Files From FTP Server With Golang?

Published on Sep 20, 2025

9 min read

How to handle concurrent file downloads from an FTP server using Golang?
How to download files from FTP server using Golang?
How to check if a file exists on an FTP server using Golang?
How to list files and directories on an FTP server using Golang?
What is the command to change the directory on an FTP server using Golang?

How to Download Files From FTP Server With Golang? image

Best FTP Server File Download Tools to Buy in January 2026

trueCABLE Wire Stripping and Cutting Tool for UTP, FTP, STP, Cat5e, Cat6, Cat6A Ethernet, RG59, RG6, RG7, RG11 Coax Cable, Adjustable Blade Depth

DURABLE ABS BUILD: LONG-LASTING TOOL WITH REPLACEABLE BLADE CASSETTES.
ERGONOMIC COMFORT: DESIGNED TO REDUCE INSTALLER FATIGUE AND IMPROVE GRIP.
VERSATILE FUNCTIONALITY: STRIPS VARIOUS CABLES; ADJUSTABLE FOR PERFECT SCORING.

BUY & SAVE

$14.99

Yankok [S501B Cable Stripping and Cutting Tool] Yellow with Adjustable Blade Depth For UTP, FTP, STP, CAT5/5e CAT6/6a Ethernet, RG59/6/7/11 Coax Cables, Date Telephone Round and Flat Wires Strip Cut

ONE-HANDED OPERATION: STRIP AND CUT VARIOUS CABLES EASILY & EFFICIENTLY.
VERSATILE STRIPPING BLADE: ADJUSTS FOR DIFFERENT INSULATION THICKNESSES SEAMLESSLY.
COMPACT & LIGHTWEIGHT: FITS IN POCKETS AND TOOL BELTS FOR ON-THE-GO CONVENIENCE.

BUY & SAVE

$10.99

LINKUP - RJ45 Connectors Cat6A (2 Pack) Shielded Zinc-Alloy Housing Modular Termination Plug | 10G Easy Internet Tool Free Plugs | for Cat6A up to 22AWG Solid Bulk S/FTP Ethernet Cable [Blue]

TRUE CAT6A PERFORMANCE: ACHIEVE 10G SPEEDS FOR ULTRA-HIGH-SPEED NEEDS.
EASY ASSEMBLY: TOOL-FREE DESIGN ENSURES QUICK AND HASSLE-FREE SETUP.
QUALITY BUILD: ROBUST CONSTRUCTION MINIMIZES INTERFERENCE FOR RELIABLE USE.

BUY & SAVE

$12.48 $24.96

Save 50%

ZOERAX 12 Pcs Cat6a Cat7 Keystone Jack Cat7 RJ45 STP Tool-Less Type Zinc Alloy Module Jacks Adapter Coupler for 22 to 26 AWG Solid or Stranded S/FTP Ethernet Cable

DURABLE METAL DESIGN: FULL METAL SHIELD FOR RELIABLE PERFORMANCE & LONGEVITY.
EASY INSTALLATION: TOOL-FREE 180° TERMINATION FOR QUICK SETUP AND VERSATILITY.
FUTURE-PROOFED: CAT 7 COMPATIBLE, ENSURING TOP PERFORMANCE FOR YEARS!

BUY & SAVE

$29.99

The Wooster Brush Company RR663-9 Pro Doo Z FTP Roller Cover 3/8-Inch Nap, 3-Pack , White

HIGH-DENSITY, SHED-RESISTANT ROLLERS FOR A SMOOTH FINISH ON ALL PAINTS.
HYDROFLOW TECH ENHANCES PAINT FLOW FOR A FLAWLESS APPLICATION.
EYE-CATCHING PACKAGING PERFECT FOR CONTRACTORS AND DIY ENTHUSIASTS.

BUY & SAVE

$15.99

trueCABLE Wire Stripping and Cutting Tool for UTP, FTP, STP, Cat5e, Cat6, Cat6A Ethernet, RG59, RG6, RG7, RG11 Coax Cable, Adjustable Blade Depth, 5 Pack

PROFESSIONAL GRADE MATERIALS ENSURE DURABILITY AND LONG-LASTING USE.
ERGONOMIC DESIGN REDUCES INSTALLER FATIGUE FOR ENHANCED PRODUCTIVITY.
VERSATILE TOOL STRIPS VARIOUS CABLES QUICKLY, SAVING YOU VALUABLE TIME.

BUY & SAVE

$63.71

ONE MORE?

To download files from an FTP server using Golang, you can follow these steps:

Import the necessary packages: import ( "fmt" "net/http" "io" "os" )
Establish an FTP connection using net/http package: response, err := http.Get("ftp://:@/") if err != nil { fmt.Println("Error connecting to FTP server:", err) return } defer response.Body.Close()
Open a new file to store the downloaded file: file, err := os.Create("") if err != nil { fmt.Println("Error creating file:", err) return } defer file.Close()
Download the file and write its contents to the new file: _, err = io.Copy(file, response.Body) if err != nil { fmt.Println("Error downloading file:", err) return }
Print a success message if the download is completed without any errors: fmt.Println("File downloaded successfully!")

Replace <username> with your FTP server username, <password> with your FTP server password, <ftp-server> with the FTP server address, <file-path> with the path of the file you want to download from the FTP server, and <[destination-file-path](https://forum.phparea.com/thread/how-to-change-canvas-image-download-path)> with the desired local path where you want to store the downloaded file.

Make sure to handle any potential errors that may occur during the download process.

How to handle concurrent file downloads from an FTP server using Golang?

To handle concurrent file downloads from an FTP server using Golang, you can utilize goroutines and channels for synchronization. Here's an example implementation:

Import the required packages:

import ( "io" "log" "net/url" "os" "path/filepath" "strconv" "strings" "sync" )

import "github.com/jlaffaye/ftp"

Define a function for downloading a file from the FTP server:

func downloadFile(ftpClient *ftp.ServerConn, remoteFilePath string, localFilePath string, wg *sync.WaitGroup, ch chan<- int) { defer wg.Done()

remoteFile, err := ftpClient.Retr(remoteFilePath)
if err != nil {
    log.Printf("Error downloading file '%s': %v\\n", remoteFilePath, err)
    ch <- 0
    return
}
defer remoteFile.Close()

localFile, err := os.Create(localFilePath)
if err != nil {
    log.Printf("Error creating local file '%s': %v\\n", localFilePath, err)
    ch <- 0
    return
}
defer localFile.Close()

\_, err = io.Copy(localFile, remoteFile)
if err != nil {
    log.Printf("Error copying remote file '%s' to local file '%s': %v\\n", remoteFilePath, localFilePath, err)
    ch <- 0
    return
}

log.Printf("Downloaded file '%s' to '%s'\\n", remoteFilePath, localFilePath)
ch <- 1

}

Define a function to recursively download files from the FTP server:

func downloadFilesFromFTP(ftpURL string, localDir string, maxDownloads int) { parsedURL, err := url.Parse(ftpURL) if err != nil { log.Fatalf("Error parsing FTP URL: %v\n", err) }

host := parsedURL.Host
path := parsedURL.Path

ftpClient, err := ftp.Dial(host)
if err != nil {
    log.Fatalf("Error connecting to FTP server '%s': %v\\n", host, err)
}
defer ftpClient.Quit()

err = ftpClient.Login("anonymous", "anonymous")
if err != nil {
    log.Fatalf("Error logging in to FTP server '%s': %v\\n", host, err)
}

err = ftpClient.ChangeDir(path)
if err != nil {
    log.Fatalf("Error changing directory to '%s' on FTP server '%s': %v\\n", path, host, err)
}

var wg sync.WaitGroup
ch := make(chan int, maxDownloads)

err = filepath.Walk(path, func(remoteFilePath string, info os.FileInfo, err error) error {
    if err != nil {
        log.Printf("Error accessing file '%s': %v\\n", remoteFilePath, err)
        return nil
    }
    
    if info.IsDir() {
        return nil
    }
    
    fileName := filepath.Base(remoteFilePath)
    localFilePath := filepath.Join(localDir, fileName)
    
    wg.Add(1)
    go downloadFile(ftpClient, remoteFilePath, localFilePath, &wg, ch)
    
    return nil
})
if err != nil {
    log.Fatalf("Error walking FTP server directory '%s': %v\\n", path, err)
}

go func() {
    wg.Wait()
    close(ch)
}()

// Wait for all downloads to complete
downloadsComplete := 0
for result := range ch {
    downloadsComplete += result
    if downloadsComplete >= maxDownloads {
        break
    }
}

log.Printf("All downloads completed\\n")

}

Start downloading files by calling the downloadFilesFromFTP function:

func main() { ftpURL := "ftp://example.com/some/directory" localDir := "/path/to/local/folder" maxDownloads := 5

downloadFilesFromFTP(ftpURL, localDir, maxDownloads)

}

Make sure to replace the FTP URL and local directory path with appropriate values for your scenario. Adjust the maxDownloads parameter to control the number of concurrent downloads.

How to download files from FTP server using Golang?

To download files from an FTP server using Golang, you can use the net and ftp packages. Here is an example code snippet to get you started:

package main

import ( "fmt" "io" "net" "os"

"github.com/jlaffaye/ftp"

)

func main() { // FTP server details host := "ftp.example.com" port := 21 username := "username" password := "password"

// Connect to the FTP server
conn, err := ftp.Connect(fmt.Sprintf("%s:%d", host, port))
if err != nil {
	panic(err)
}
defer conn.Quit()

// Login to the FTP server
err = conn.Login(username, password)
if err != nil {
	panic(err)
}

// Change to the desired directory (optional)
err = conn.ChangeDir("path/to/directory")
if err != nil {
	panic(err)
}

// Retrieve the list of files in the current directory
files, err := conn.List("")
if err != nil {
	panic(err)
}

// Download each file in the current directory
for \_, file := range files {
	fmt.Println("Downloading:", file.Name)
	err = downloadFile(conn, file.Name)
	if err != nil {
		fmt.Println("Failed to download file:", file.Name)
		fmt.Println(err)
	}
}

}

func downloadFile(conn *ftp.ServerConn, filename string) error { // Open a new file for writing file, err := os.Create(filename) if err != nil { return err } defer file.Close()

// Retrieve the file from the FTP server
r, err := conn.Retr(filename)
if err != nil {
	return err
}
defer r.Close()

// Copy the contents of the file to the local file
\_, err = io.Copy(file, r)
if err != nil {
	return err
}
fmt.Println("Downloaded:", filename)
return nil

}

In this example, replace the FTP server details (host, port, username, and password) with the appropriate values for your FTP server. The code connects to the FTP server, logs in with the provided credentials, changes to the desired directory (if needed), retrieves the list of files in the current directory, and then downloads each file by copying its contents to a local file. The downloaded files will be saved in the current directory.

How to check if a file exists on an FTP server using Golang?

To check if a file exists on an FTP server using Golang, you can use the ftp package which provides an interface to interact with FTP servers.

Here's an example code snippet showing how to check if a file exists on an FTP server:

package main

import ( "fmt" "log" "os"

"github.com/jlaffaye/ftp"

)

func fileExistsOnFTPServer(serverAddr, username, password, filePath string) (bool, error) { // Connect to the FTP server client, err := ftp.Connect(serverAddr) if err != nil { return false, err } defer client.Quit()

// Login to the FTP server
err = client.Login(username, password)
if err != nil {
	return false, err
}

// Check if file exists
\_, err = client.Retr(filePath)
if err != nil {
	if err == ftp.ErrFileNotFound {
		return false, nil
	}
	return false, err
}

return true, nil

}

func main() { serverAddr := "ftp.example.com" username := "username" password := "password" filePath := "/path/to/file.txt"

exists, err := fileExistsOnFTPServer(serverAddr, username, password, filePath)
if err != nil {
	log.Fatal(err)
}

if exists {
	fmt.Println("File exists on FTP server.")
} else {
	fmt.Println("File does not exist on FTP server.")
}

}

Make sure to replace the serverAddr, username, password, and filePath variables with the actual FTP server details and the file path you want to check.

How to list files and directories on an FTP server using Golang?

To list files and directories on an FTP server using Golang, you can use the net and ftp packages. Here's an example code to achieve this:

package main

import ( "fmt" "io/ioutil" "net" "os" "strings" )

func main() { ftpServer := "ftp.example.com" ftpUser := "username" ftpPass := "password"

// Connect to FTP server
conn, err := net.Dial("tcp", ftpServer+":21")
if err != nil {
	fmt.Println("Error connecting to FTP server:", err)
	return
}
defer conn.Close()

// Read server response
response, \_ := readResponse(conn)
fmt.Println(response)

// Send username
cmd := "USER " + ftpUser + "\\r\\n"
sendCommand(conn, cmd)
response, \_ = readResponse(conn)
fmt.Println(response)

// Send password
cmd = "PASS " + ftpPass + "\\r\\n"
sendCommand(conn, cmd)
response, \_ = readResponse(conn)
fmt.Println(response)

// Send PASV command to enter passive mode
sendCommand(conn, "PASV\\r\\n")
response, \_ = readResponse(conn)
fmt.Println(response)

// Extract port number from PASV response
port := getPort(response)

// Open data connection
dataConn, err := net.Dial("tcp", ftpServer+":"+port)
if err != nil {
	fmt.Println("Error connecting to FTP data port:", err)
	return
}
defer dataConn.Close()

// Send LIST command to get file/directory listing
sendCommand(conn, "LIST\\r\\n")
response, \_ = readResponse(conn)
fmt.Println(response)

// Read directory listing from data connection
listing, \_ := ioutil.ReadAll(dataConn)
fmt.Println(string(listing))

}

// Read response from the server func readResponse(conn net.Conn) (string, error) { response := make([]byte, 1024) _, err := conn.Read(response) return string(response), err }

// Send command to the server func sendCommand(conn net.Conn, cmd string) { conn.Write([]byte(cmd)) }

// Extract port number from PASV response func getPort(response string) string { start := strings.Index(response, "(") end := strings.Index(response, ")") fields := strings.Split(response[start:end], ",") port := fmt.Sprintf("%s.%s.%s.%s:%d", strings.Trim(fields[0], "("), fields[1], fields[2], fields[3], (((256 * int(fields[4])) + int(fields[5])))) return port }

Make sure to replace ftp.example.com, username, and password with the appropriate values for your FTP server. This code establishes a connection to the FTP server, authenticates with a username and password, enters passive mode, sends the LIST command to get the file/directory listing, and then reads and prints the listing.

What is the command to change the directory on an FTP server using Golang?

In Golang, you can change the directory on an FTP server using the ChangeDir function from the ftp package.

Here's an example of how to use it:

package main

import ( "fmt" "github.com/jlaffaye/ftp" "log" )

func main() { // Connect to FTP server client, err := ftp.Dial("ftp.example.com:21") if err != nil { log.Fatal(err) }

// Login to FTP server
err = client.Login("username", "password")
if err != nil {
	log.Fatal(err)
}

// Change directory
err = client.ChangeDir("/path/to/directory")
if err != nil {
	log.Fatal(err)
}

// Print current directory
pwd, err := client.CurrentDir()
if err != nil {
	log.Fatal(err)
}
fmt.Println("Current directory:", pwd)

// Logout and quit
err = client.Quit()
if err != nil {
	log.Fatal(err)
}

}

Make sure to replace "ftp.example.com", "username", "password", and "/path/to/directory" with the actual FTP server details.