Are you happy with your logging solution? Would you help us out by taking a 30-second survey? Click here


Fast HTTP package for Go. Tuned for high performance. Zero memory allocations in hot paths. Up to 10x faster than net/http

Subscribe to updates I use fasthttp

Statistics on fasthttp

Number of watchers on Github 5856
Number of open issues 153
Average time to close an issue 4 days
Main language Go
Average time to merge a PR 2 days
Open pull requests 44+
Closed pull requests 19+
Last commit about 2 years ago
Repo Created about 4 years ago
Repo Last Updated almost 2 years ago
Size 1.32 MB
Organization / Authorvalyala
Latest Releasev20160617
Page Updated
Do you use fasthttp? Leave a review!
View open issues (153)
View fasthttp activity
View on github
Fresh, new opensource launches 🚀🚀🚀
Trendy new open source projects in your inbox! View examples

Subscribe to our mailing list

Evaluating fasthttp for your project? Score Explanation
Commits Score (?)
Issues & PR Score (?)

Build Status GoDoc Go Report


Fast HTTP implementation for Go.

Currently fasthttp is successfully used by VertaMedia in a production serving up to 200K rps from more than 1.5M concurrent keep-alive connections per physical server.

TechEmpower Benchmark round 12 results

Server Benchmarks

Client Benchmarks



Examples from docs

Code examples

Switching from net/http to fasthttp

Fasthttp best practices

Tricks with byte buffers

Related projects


HTTP server performance comparison with net/http

In short, fasthttp server is up to 10 times faster than net/http. Below are benchmark results.


net/http server:

$ GOMAXPROCS=1 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn                     1000000         12052 ns/op        2297 B/op         29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn                     1000000         12278 ns/op        2327 B/op         24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn                    2000000          8903 ns/op        2112 B/op         19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn                   2000000          8451 ns/op        2058 B/op         18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients            500000         26733 ns/op        3229 B/op         29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients           1000000         23351 ns/op        3211 B/op         24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients          1000000         13390 ns/op        2483 B/op         19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients         1000000         13484 ns/op        2171 B/op         18 allocs/op

fasthttp server:

$ GOMAXPROCS=1 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn                           10000000          1559 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet2ReqPerConn                           10000000          1248 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10ReqPerConn                          20000000           797 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10KReqPerConn                         20000000           716 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients                 10000000          1974 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients                 10000000          1352 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients                20000000           789 ns/op           2 B/op          0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients               20000000           604 ns/op           0 B/op          0 allocs/op


net/http server:

$ GOMAXPROCS=4 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn-4                       3000000          4529 ns/op        2389 B/op         29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn-4                       5000000          3896 ns/op        2418 B/op         24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn-4                      5000000          3145 ns/op        2160 B/op         19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn-4                     5000000          3054 ns/op        2065 B/op         18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients-4             1000000         10321 ns/op        3710 B/op         30 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients-4             2000000          7556 ns/op        3296 B/op         24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients-4            5000000          3905 ns/op        2349 B/op         19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients-4           5000000          3435 ns/op        2130 B/op         18 allocs/op

fasthttp server:

$ GOMAXPROCS=4 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn-4                             10000000          1141 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet2ReqPerConn-4                             20000000           707 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10ReqPerConn-4                            30000000           341 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10KReqPerConn-4                           50000000           310 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients-4                   10000000          1119 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients-4                   20000000           644 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients-4                  30000000           346 ns/op           0 B/op          0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients-4                 50000000           282 ns/op           0 B/op          0 allocs/op

HTTP client comparison with net/http

In short, fasthttp client is up to 10 times faster than net/http. Below are benchmark results.


net/http client:

$ GOMAXPROCS=1 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer                       1000000         12567 ns/op        2616 B/op         35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP                     200000         67030 ns/op        5028 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP                    300000         51098 ns/op        5031 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP                   300000         45096 ns/op        5026 B/op         55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory                500000         24779 ns/op        5035 B/op         57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory              1000000         26425 ns/op        5035 B/op         57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory              500000         28515 ns/op        5045 B/op         57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory             500000         39511 ns/op        5096 B/op         56 allocs/op

fasthttp client:

$ GOMAXPROCS=1 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer                             20000000           865 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1TCP                           1000000         18711 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd10TCP                          1000000         14664 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd100TCP                         1000000         14043 ns/op           1 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory                      5000000          3965 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory                     3000000          4060 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory                    5000000          3396 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory                   5000000          3306 ns/op           2 B/op          0 allocs/op


net/http client:

$ GOMAXPROCS=4 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer-4                         2000000          8774 ns/op        2619 B/op         35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP-4                       500000         22951 ns/op        5047 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP-4                     1000000         19182 ns/op        5037 B/op         55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP-4                    1000000         16535 ns/op        5031 B/op         55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory-4                 1000000         14495 ns/op        5038 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory-4                1000000         10237 ns/op        5034 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory-4               1000000         10125 ns/op        5045 B/op         56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory-4              1000000         11132 ns/op        5136 B/op         56 allocs/op

fasthttp client:

$ GOMAXPROCS=4 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer-4                               50000000           397 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1TCP-4                             2000000          7388 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd10TCP-4                            2000000          6689 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd100TCP-4                           3000000          4927 ns/op           1 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory-4                       10000000          1604 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory-4                      10000000          1458 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory-4                     10000000          1329 ns/op           0 B/op          0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory-4                    10000000          1316 ns/op           5 B/op          0 allocs/op


go get -u

Switching from net/http to fasthttp

Unfortunately, fasthttp doesn't provide API identical to net/http. See the FAQ for details. There is net/http -> fasthttp handler converter, but it is better to write fasthttp request handlers by hand in order to use all of the fasthttp advantages (especially high performance :) ).

Important points:

  type MyHandler struct {
    foobar string

  // request handler in net/http style, i.e. method bound to MyHandler struct.
  func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
    // notice that we may access MyHandler properties here - see h.foobar.
    fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
        ctx.Path(), h.foobar)

  // request handler in fasthttp style, i.e. just plain function.
  func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
    fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())

  // pass bound struct method to fasthttp
  myHandler := &MyHandler{
    foobar: "foobar",
  fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)

  // pass plain function to fasthttp
  fasthttp.ListenAndServe(":8081", fastHTTPHandler)
  • The RequestHandler accepts only one argument - RequestCtx. It contains all the functionality required for http request processing and response writing. Below is an example of a simple request handler conversion from net/http to fasthttp.
  // net/http request handler
  requestHandler := func(w http.ResponseWriter, r *http.Request) {
    switch r.URL.Path {
    case "/foo":
        fooHandler(w, r)
    case "/bar":
        barHandler(w, r)
        http.Error(w, "Unsupported path", http.StatusNotFound)
  // the corresponding fasthttp request handler
  requestHandler := func(ctx *fasthttp.RequestCtx) {
    switch string(ctx.Path()) {
    case "/foo":
    case "/bar":
        ctx.Error("Unsupported path", fasthttp.StatusNotFound)
  • Fasthttp allows setting response headers and writing response body in an arbitrary order. There is no 'headers first, then body' restriction like in net/http. The following code is valid for fasthttp:
  requestHandler := func(ctx *fasthttp.RequestCtx) {
    // set some headers and status code first

    // then write the first part of body
    fmt.Fprintf(ctx, "this is the first part of body\n")

    // then set more headers
    ctx.Response.Header.Set("Foo-Bar", "baz")

    // then write more body
    fmt.Fprintf(ctx, "this is the second part of body\n")

    // then override already written body
    ctx.SetBody([]byte("this is completely new body contents"))

    // then update status code

    // basically, anything may be updated many times before
    // returning from RequestHandler.
    // Unlike net/http fasthttp doesn't put response to the wire until
    // returning from RequestHandler.

Net/http code with simple ServeMux is trivially converted to fasthttp code:

  // net/http code

  m := &http.ServeMux{}
  m.HandleFunc("/foo", fooHandlerFunc)
  m.HandleFunc("/bar", barHandlerFunc)
  m.Handle("/baz", bazHandler)

  http.ListenAndServe(":80", m)
  // the corresponding fasthttp code
  m := func(ctx *fasthttp.RequestCtx) {
    switch string(ctx.Path()) {
    case "/foo":
    case "/bar":
    case "/baz":
        ctx.Error("not found", fasthttp.StatusNotFound)

  fasthttp.ListenAndServe(":80", m)

Use this brilliant tool - race detector - for detecting and eliminating data races in your program. If you detected data race related to fasthttp in your program, then there is high probability you forgot calling TimeoutError before returning from RequestHandler.

Performance optimization tips for multi-core systems

  • Use reuseport listener.
  • Run a separate server instance per CPU core with GOMAXPROCS=1.
  • Pin each server instance to a separate CPU core using taskset.
  • Ensure the interrupts of multiqueue network card are evenly distributed between CPU cores. See this article for details.
  • Use Go 1.6 as it provides some considerable performance improvements.

Fasthttp best practices

  • Do not allocate objects and []byte buffers - just reuse them as much as possible. Fasthttp API design encourages this.
  • sync.Pool is your best friend.
  • Profile your program in production. go tool pprof --alloc_objects your-program mem.pprof usually gives better insights for optimization opportunities than go tool pprof your-program cpu.pprof.
  • Write tests and benchmarks for hot paths.
  • Avoid conversion between []byte and string, since this may result in memory allocation+copy. Fasthttp API provides functions for both []byte and string - use these functions instead of converting manually between []byte and string. There are some exceptions - see this wiki page for more details.
  • Verify your tests and production code under race detector on a regular basis.
  • Prefer quicktemplate instead of html/template in your webserver.

Tricks with []byte buffers

The following tricks are used by fasthttp. Use them in your code too.

  • Standard Go functions accept nil buffers ```go var ( // both buffers are uninitialized dst []byte src []byte ) dst = append(dst, src...) // is legal if dst is nil and/or src is nil copy(dst, src) // is legal if dst is nil and/or src is nil (string(src) == "") // is true if src is nil (len(src) == 0) // is true if src is nil src = src[:0] // works like a charm with nil src

// this for loop doesn't panic if src is nil for i, ch := range src { doSomething(i, ch) }

So throw away nil checks for `[]byte` buffers from you code. For example,
srcLen := 0
if src != nil {
    srcLen = len(src)


srcLen := len(src)
  • String may be appended to []byte buffer with append

    dst = append(dst, "foobar"...)
  • []byte buffer may be extended to its' capacity.

    buf := make([]byte, 100)
    a := buf[:10]  // len(a) == 10, cap(a) == 100.
    b := a[:100]  // is valid, since cap(a) == 100.
  • All fasthttp functions accept nil []byte buffer

    statusCode, body, err := fasthttp.Get(nil, "")
    uintBuf := fasthttp.AppendUint(nil, 1234)

Related projects

  • fasthttp-contrib - various useful helpers for projects based on fasthttp.
  • iris - web application framework built on top of fasthttp. Features speed and functionality.
  • fasthttp-routing - fast and powerful routing package for fasthttp servers.
  • fasthttprouter - a high performance fasthttp request router that scales well.
  • lu - a high performance go middleware web framework which is based on fasthttp.
  • websocket - Gorilla-based websocket implementation for fasthttp.


  • Why creating yet another http package instead of optimizing net/http?

Because net/http API limits many optimization opportunities. For example:

  • net/http Request object lifetime isn't limited by request handler execution time. So the server must create a new request object per each request instead of reusing existing objects like fasthttp does.
  • net/http headers are stored in a map[string][]string. So the server must parse all the headers, convert them from []byte to string and put them into the map before calling user-provided request handler. This all requires unnecessary memory allocations avoided by fasthttp.
  • net/http client API requires creating a new response object per each request.

    • Why fasthttp API is incompatible with net/http?

Because net/http API limits many optimization opportunities. See the answer above for more details. Also certain net/http API parts are suboptimal for use:

There are plans for adding HTTP/2.0 and WebSockets support in the future. In the mean time, third parties may use RequestCtx.Hijack for implementing these goodies. See the first third-party websocket implementation on the top of fasthttp.

  • Are there known net/http advantages comparing to fasthttp?


  • net/http supports HTTP/2.0 starting from go1.6.
  • net/http API is stable, while fasthttp API constantly evolves.
  • net/http handles more HTTP corner cases.
  • net/http should contain less bugs, since it is used and tested by much wider audience.
  • net/http works on Go older than 1.5.

    • Why fasthttp API prefers returning []byte instead of string?

Because []byte to string conversion isn't free - it requires memory allocation and copy. Feel free wrapping returned []byte result into string() if you prefer working with strings instead of byte slices. But be aware that this has non-zero overhead.

  • Which GO versions are supported by fasthttp?

Go1.5+. Older versions won't be supported, since their standard package miss useful functions.

  • Please provide real benchmark data and sever information

See this issue.

  • Are there plans to add request routing to fasthttp?

There are no plans to add request routing into fasthttp. Use third-party routers and web frameworks with fasthttp support:

* [Iris](
* [fasthttp-routing](
* [fasthttprouter](
* [gramework](
* [lu](

See also this issue for more info.

  • I detected data race in fasthttp!

Cool! File a bug. But before doing this check the following in your code:

  • Make sure there are no references to RequestCtx or to its' members after returning from RequestHandler.
  • Make sure you call TimeoutError before returning from RequestHandler if there are references to RequestCtx or to its' members, which may be accessed by other goroutines.

    • I didn't find an answer for my question here

Try exploring these questions.

fasthttp open issues Ask a question     (View All Issues)
  • about 3 years Pipeline Client seems to be slow
  • about 3 years Connection refused (echo/fasthttp)
  • about 3 years DelClientCookie doesn't delete cookie with path
  • about 3 years "?" is replaced by ";" in Location with client.Do() when the server redirect
  • over 3 years Cookies with max-age
  • over 3 years Cookie parse not working with upper case attributes
  • over 3 years Peek Headers with the same name
  • over 3 years Not working example with reuseport
  • over 3 years there does exist long latency before c.ConnTime()
  • over 3 years error when serving connection ,body error
  • over 3 years Cookie.ParseBytes parse expires maybe has a bug
  • over 3 years client HEAD request
  • over 3 years Ridiculously large headers cause connection to be reset without response
  • over 3 years Google App Engine Support
  • over 3 years Why I got response from server:fasthttp occasionally?
  • over 3 years Tests are not passing on mac with go1.7.
  • over 3 years How can I visit a website through http proxy?
  • over 3 years TLS configuration
  • over 3 years Cannot follow redirect when using Do() but Get() doesn't expose `Request` object for fine-grain control
  • over 3 years Are you using caching?
  • over 3 years More convenient method to get all cookies than `VisitAllCookie()`
  • over 3 years http.Transport.Dial adapter (for SOCKS5 proxy support)
  • over 3 years error when serving connection
  • over 3 years Do I need NGINX?
  • over 3 years Wrong redirect with relative path for https
  • over 3 years Please do not reset connection due the postBodySize exceeds the given limit
  • over 3 years Why do Response.AppendBodyString use so much memory?
  • over 3 years Why does func Get have `dst` parameter?
  • over 3 years How to get the file size when uploading it?
  • over 3 years Semicolon separate in URI args
fasthttp open pull requests (View All Pulls)
  • [WIP] Add ProxyClient
  • Keep Server header on reset
  • Fix Go Report badge in README
  • Proof of Concept: handling huge/endless response body
  • Asynchronous processing of RequestCtx in a goroutine
  • fix DoDeadline side effect when no free connection
  • Redirection support for Do(*Request, *Response) for Issue #165
  • fix large number of goroutine connsCleaner()
  • Deprecate ByteBuffer and use bytebufferpool.ByteBuffer
  • Get multiple header values with same key
  • Adding support to case-insensitive cookie attributes
  • Adding WriteDeflate[Level] and AppendDeflateBytes[Level] methods
  • Read GET/HEAD body if it exists
  • Adding errors Request/Response reads
  • Support multiple form files
  • Update server.go
  • Fixes #157 - https-detection
  • Related projects: Add GeekyPanda/httpcache
  • fix some typos
  • Remove iris from README, latest v6 removes fasthttp support
  • Add ';' to unescaped characters
  • misc typo fixes
  • Fix hex2intTable out of range bug
  • Schema changes detection with HostClient
  • Add pprofhandler, fix #235
  • http: Use full URI in request line
  • Use random ports for tests
  • Add IsConnect method
  • Don't try to compress 204 or 304
  • Added `Door` router
  • Should reset all fields of the clientConn when you release it.
  • Configuration for automatic retry for idempotent calls
  • Parsing Origin From the Request Header
  • Update README to mention phi
  • Typo fixes
  • Allow overwrite of ContentType by caller of RequestCtx.ServeFile
  • Added GetPostArgs which returns Args and error
  • Do not log ErrSmallBuffer for request headers unless LogAllErrors is set
  • add alice
  • Make maxAttempts in client.go configurable via HostClient.MaxAttempts
  • Fix premature connection closing.
  • choose correctness over speed for connection: close
  • Fix readme: update 3rd-party library list
  • Add missing http methods
fasthttp list of languages used
Other projects in Go