Skip to content
The official implementation of the tus resumable upload protocol.
Find file
Failed to load latest commit information.
cmd/tusd Add version information for tusd builds
consullocker Add locking using Consul
filestore Add test for FileStore.ConcatUploads
limitedstore Expose additional interfaces in LimitedStore
memorylocker Fix documentation styling for memorylocker
s3store Provide better URL to S3 consistency models
uid rewrite tusd
vendor/ Update dependencies
.gitignore Move infra builder to own repo
.gitmodules Update dependencies
.travis.yml Test Golang 1.6 Release Candidate 2
LICENSE.txt rewrite tusd Remove Go 1.2 as supported target
appveyor.yml Do not run test verbose on AppVeyor
concat_test.go Use assertions library for tests
cors_test.go Extract tests into tusd_test package
datastore.go Extract concatenation into own interface
get_test.go Extract tests into tusd_test package
handler.go Extract GetReader into own interface
handler_test.go Remove unused GetReader function from tests
head_test.go Extract tests into tusd_test package
options_test.go Extract concatenation into own interface
patch_test.go Use assertions library for tests
post_test.go Add RespectForwardedHeaders option to handlers
terminate_test.go Extract concatenation into own interface
unrouted_handler.go Merge branch 'forwarded-host'


Build Status Build status

tusd is the official reference implementation of the tus resumable upload protocol. The protocol specifies a flexible method to upload files to remote servers using HTTP. The special feature is the ability to pause and resume uploads at any moment allowing to continue seamlessly after e.g. network interruptions.

Protocol version: 1.0.0

Getting started


  • Go (1.3 or newer)

Running tusd from source:

Clone the git repository and cd into it.

git clone
cd tusd

Now you can run tusd:

go run cmd/tusd/main.go

Using tusd manually

Besides from running tusd using the provided binary, you can embed it into your own Golang program:

package main

import (

func main() {
    // Create a new FileStore instance which is responsible for
    // storing the uploaded file on disk in the specified directory.
    // If you want to save them on a different medium, for example
    // a remote FTP server, you can implement your own storage backend
    // by implementing the tusd.DataStore interface.
    store := filestore.FileStore{
        Path: "./uploads",

    // Create a new HTTP handler for the tusd server by providing
    // a configuration object. The DataStore property must be set
    // in order to allow the handler to function.
    handler, err := tusd.NewHandler(tusd.Config{
        BasePath:              "files/",
        DataStore:             store,
    if err != nil {
        panic("Unable to create handler: %s", err)

    // Right now, nothing has happened since we need to start the
    // HTTP server on our own. In the end, tusd will listen on
    // and accept request at http://localhost:8080/files
    http.Handle("files/", http.StripPrefix("files/", handler))
    err = http.ListenAndServe(":8080", nil)
    if err != nil {
        panic("Unable to listen: %s", err)

If you need to customize the GET and DELETE endpoints use tusd.NewUnroutedHandler instead of tusd.NewHandler.

Implementing own storages

The tusd server is built to be as flexible as possible and to allow the use of different upload storage mechanisms. By default the tusd binary includes filestore which will save every upload to a specific directory on disk.

If you have different requirements, you can build your own storage backend which will save the files to S3, a remote FTP server or similar. Doing so is as simple as implementing the tusd.DataStore interface and using the new struct in the configuration object. Please consult the documentation about detailed information about the required methods.

Running the testsuite

go test -v ./...


This project is licensed under the MIT license, see LICENSE.txt.

Something went wrong with that request. Please try again.