Part 2) Download Large Files with Progress Reports

· 461 words · 3 minutes read

We've already covered basic downloading of files - this post goes beyond that to create a more complete downloader by including progress reporting of the download. This means if you're pulling down large files you are able to see how the download's going.

In our basic example we pass the response body into io.Copy() but if we use a TeeReader we can pass our counter to keep track of the progress.

We also save the file as a temporary file while downloading so we don't overwrite a valid file until the file is fully downloaded.

package main

import (


// WriteCounter counts the number of bytes written to it. It implements to the io.Writer interface
// and we can pass this into io.TeeReader() which will report progress on each write cycle.
type WriteCounter struct {
	Total uint64

func (wc *WriteCounter) Write(p []byte) (int, error) {
	n := len(p)
	wc.Total += uint64(n)
	return n, nil

func (wc WriteCounter) PrintProgress() {
	// Clear the line by using a character return to go back to the start and remove
	// the remaining characters by filling it with spaces
	fmt.Printf("\r%s", strings.Repeat(" ", 35))

	// Return again and print current status of download
	// We use the humanize package to print the bytes in a meaningful way (e.g. 10 MB)
	fmt.Printf("\rDownloading... %s complete", humanize.Bytes(wc.Total))

func main() {
	fmt.Println("Download Started")

	fileUrl := ""
	err := DownloadFile("avatar.jpg", fileUrl)
	if err != nil {

	fmt.Println("Download Finished")

// DownloadFile will download a url to a local file. It's efficient because it will
// write as it downloads and not load the whole file into memory. We pass an io.TeeReader
// into Copy() to report progress on the download.
func DownloadFile(filepath string, url string) error {

	// Create the file, but give it a tmp file extension, this means we won't overwrite a
	// file until it's downloaded, but we'll remove the tmp extension once downloaded.
	out, err := os.Create(filepath + ".tmp")
	if err != nil {
		return err

	// Get the data
	resp, err := http.Get(url)
	if err != nil {
		return err
	defer resp.Body.Close()

	// Create our progress reporter and pass it to be used alongside our writer
	counter := &WriteCounter{}
	if _, err = io.Copy(out, io.TeeReader(resp.Body, counter)); err != nil {
		return err

	// The progress use the same line so print a new line once it's finished downloading

	// Close the file without defer so it can happen before Rename()

	if err = os.Rename(filepath+".tmp", filepath); err != nil {
		return err
	return nil

This will output:

$ go run download-file.go 
Download Started
Downloading... 111 MB complete     
Download Finished

And here's what it looks like:

Image of Author Edd Turtle

Author:  Edd Turtle

Edd is the Lead Developer at Hoowla, a prop-tech startup, where he spends much of his time working on production-ready Go and PHP code. He loves coding, but also enjoys cycling and camping in his spare time.

See something which isn't right? You can contribute to this page on GitHub or just let us know in the comments below - Thanks for reading!