How Can I Efficiently Download a Large File Using Go?

A more descriptive version of Steve M's answer.

import (
    "os"
    "net/http"
    "io"
)

func downloadFile(filepath string, url string) (err error) {

  // Create the file
  out, err := os.Create(filepath)
  if err != nil  {
    return err
  }
  defer out.Close()

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

  // Check server response
  if resp.StatusCode != http.StatusOK {
    return fmt.Errorf("bad status: %s", resp.Status)
  }

  // Writer the body to file
  _, err = io.Copy(out, resp.Body)
  if err != nil  {
    return err
  }

  return nil
}

The answer selected above using io.Copy is exactly what you need, but if you are interested in additional features like resuming broken downloads, auto-naming files, checksum validation or monitoring progress of multiple downloads, checkout the grab package.

I also think it's nice to have a progress indicator, especially for larger files. So I want to throw in my two cents for a solution to this problem while implementing a simple progress indicator. (Most error handling also omitted for brevety).

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
)

func main() {
    temp_path := ".tmp"
    req, _ := http.NewRequest("GET", "", nil)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    f, _ := os.OpenFile(temp_path, os.O_CREATE|os.O_WRONLY, 0644)
    defer f.Close()

    buf := make([]byte, 32*1024)
    var downloaded int64
    for {
        n, err := resp.Body.Read(buf)
        if err != nil {
            if err == io.EOF {
                break
            }
            log.Fatalf("Error while downloading: %v", err)
        }
        if n > 0 {
            f.Write(buf[:n])
            downloaded += int64(n)
            fmt.Printf("\rDownloading... %.2f%%", float64(downloaded)/float64(resp.ContentLength)*100)
        }
    }
    os.Rename(temp_path, "wordpress.zip")
}

To use io.Copy we can implement an io.Reader . Which probably will be the preferred approach in a real world scenario to make it reusable and easier to test. So here is the second version:

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "time"
)

type ProgressReader struct {
    Reader io.Reader
    Size   int64
    Pos    int64
}

func (pr *ProgressReader) Read(p []byte) (int, error) {
    n, err := pr.Reader.Read(p)
    if err == nil {
        pr.Pos += int64(n)
        fmt.Printf("\rDownloading... %.2f%%", float64(pr.Pos)/float64(pr.Size)*100)
    }
    return n, err
}

func main() {
    start := time.Now().UnixMilli()
    tempPath := ".tmp"
    outPath := "200MB.zip"
    req, _ := http.NewRequest("GET", "", nil)
    resp, _ := http.DefaultClient.Do(req)
    if resp.StatusCode != 200 {
        log.Fatalf("Error while downloading: %v", resp.StatusCode)
    }
    defer resp.Body.Close()

    f, _ := os.OpenFile(tempPath, os.O_CREATE|os.O_WRONLY, 0644)
    defer f.Close()

    progressReader := &ProgressReader{
        Reader: resp.Body,
        Size:   resp.ContentLength,
    }

    if _, err := io.Copy(f, progressReader); err != nil {
        log.Fatalf("Error while downloading: %v", err)
    }

    os.Rename(tempPath, outPath)
    fmt.Println(" - Download completed!")

    fmt.Printf("Took: %.2fs\n", float64(time.Now().UnixMilli()-start)/1000)
}