> For the complete documentation index, see [llms.txt](https://docs.couchdrop.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.couchdrop.io/walkthroughs/sftp-recipes/using-sftp-clients/using-sftp-with-golang.md).

# Using SFTP with Golang

Uploading and downloading files programatically with Golang is a great way to automate transfers or build out support for SFTP inside you application.

## How to use SFTP with Golang

To interact with SFTP servers in Go, you can use the `github.com/pkg/sftp` package, which provides SFTP support on top of `github.com/pkg/ssh`. Here's a basic guide on how to use Go with SFTP:

1. **Install Dependencies**: First, you need to install the required dependencies using `go get`:

   ```bash
   go get golang.org/x/crypto/ssh
   go get github.com/pkg/sftp
   ```
2. **Create an SSH Client and Connect to the Server**: Below is an example of how to connect to an SFTP server using Go:

   ```go
   package main

   import (
       "fmt"
       "golang.org/x/crypto/ssh"
       "github.com/pkg/sftp"
       "os"
   )

   func main() {
       // SFTP connection parameters
       host := "sftp.example.com"
       port := 22
       user := "your_username"
       password := "your_password"

       // Create SSH client configuration
       config := &ssh.ClientConfig{
           User: user,
           Auth: []ssh.AuthMethod{
               ssh.Password(password),
           },
           HostKeyCallback: ssh.InsecureIgnoreHostKey(),
       }

       // Connect to the SSH server
       conn, err := ssh.Dial("tcp", fmt.Sprintf("%s:%d", host, port), config)
       if err != nil {
           fmt.Println("Failed to connect to SSH server:", err)
           return
       }
       defer conn.Close()

       // Open SFTP session
       sftpClient, err := sftp.NewClient(conn)
       if err != nil {
           fmt.Println("Failed to open SFTP session:", err)
           return
       }
       defer sftpClient.Close()

       // Now you can perform SFTP operations using the sftpClient
   }
   ```
3. **Perform SFTP Operations**: Once you've established an SFTP connection, you can perform various operations such as uploading files, downloading files, listing directory contents, creating directories, etc. Here are a few examples:
   * **Upload a file**:

     ```go
     localFile, err := os.Open("/path/to/local/file.txt")
     if err != nil {
         fmt.Println("Failed to open local file:", err)
         return
     }
     defer localFile.Close()

     remoteFile, err := sftpClient.Create("/path/to/remote/file.txt")
     if err != nil {
         fmt.Println("Failed to create remote file:", err)
         return
     }
     defer remoteFile.Close()

     _, err = io.Copy(remoteFile, localFile)
     if err != nil {
         fmt.Println("Failed to upload file:", err)
         return
     }
     ```
   * **Download a file**:

     ```go
     remoteFile, err := sftpClient.Open("/path/to/remote/file.txt")
     if err != nil {
         fmt.Println("Failed to open remote file:", err)
         return
     }
     defer remoteFile.Close()

     localFile, err := os.Create("/path/to/local/file.txt")
     if err != nil {
         fmt.Println("Failed to create local file:", err)
         return
     }
     defer localFile.Close()

     _, err = io.Copy(localFile, remoteFile)
     if err != nil {
         fmt.Println("Failed to download file:", err)
         return
     }
     ```
4. **Close the Connection**: After you've finished with the SFTP operations, make sure to close the SFTP session and the SSH connection:

   ```go
   // Close SFTP session
   sftpClient.Close()

   // Close SSH connection
   conn.Close()
   ```

By following these steps, you can use Go to interact with SFTP servers and perform various file operations. Make sure to handle errors appropriately when dealing with network connections and file operations.

## Using Golang and SFTP with Couchdrop

Couchdrop has full support for SFTP uploads with Golang. Simply use your Couchdrop hostname and credentials and you can connect to Couchdrop like any other SFTP server. 

Couchdrop also has a comprehensive API, that you can find [couchdrop-api](https://developers.couchdrop.io/)

<br>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.couchdrop.io/walkthroughs/sftp-recipes/using-sftp-clients/using-sftp-with-golang.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.