Need help with chi?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

10.1K Stars 690 Forks MIT License 678 Commits 27 Opened issues


lightweight, idiomatic and composable router for building Go HTTP services

Services available


Need anything else?

Contributors list


GoDoc Widget Travis Widget

is a lightweight, idiomatic and composable router for building Go HTTP services. It's especially good at helping you write large REST API services that are kept maintainable as your project grows and changes.
is built on the new
package introduced in Go 1.7 to handle signaling, cancelation and request-scoped values across a handler chain.

The focus of the project has been to seek out an elegant and comfortable design for writing REST API servers, written during the development of the Pressly API service that powers our public API service, which in turn powers all of our client-side applications.

The key considerations of chi's design are: project structure, maintainability, standard http handlers (stdlib-only), developer productivity, and deconstructing a large system into many small parts. The core router
is quite small (less than 1000 LOC), but we've also included some useful/optional subpackages: middleware, render and docgen. We hope you enjoy it too!


go get -u


  • Lightweight - cloc'd in ~1000 LOC for the chi router
  • Fast - yes, see benchmarks
  • 100% compatible with net/http - use any http or middleware pkg in the ecosystem that is also compatible with
  • Designed for modular/composable APIs - middlewares, inline middlewares, route groups and sub-router mounting
  • Context control - built on new
    package, providing value chaining, cancellations and timeouts
  • Robust - in production at Pressly, CloudFlare, Heroku, 99Designs, and many others (see discussion)
  • Doc generation -
    auto-generates routing documentation from your source to JSON or Markdown
  • Go.mod support - as of v5, go.mod support (see CHANGELOG)
  • No external dependencies - plain ol' Go stdlib + net/http


See _examples/ for a variety of examples.

As easy as:

package main

import ( "net/http"



func main() { r := chi.NewRouter() r.Use(middleware.Logger) r.Get("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("welcome")) }) http.ListenAndServe(":3000", r) }

REST Preview:

Here is a little preview of how routing looks like with chi. Also take a look at the generated routing docs in JSON (routes.json) and in Markdown (

I highly recommend reading the source of the examples listed above, they will show you all the features of chi and serve as a good form of documentation.

import (

func main() { r := chi.NewRouter()

// A good base middleware stack r.Use(middleware.RequestID) r.Use(middleware.RealIP) r.Use(middleware.Logger) r.Use(middleware.Recoverer)

// Set a timeout value on the request context (ctx), that will signal // through ctx.Done() that the request has timed out and further // processing should be stopped. r.Use(middleware.Timeout(60 * time.Second))

r.Get("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("hi")) })

// RESTy routes for "articles" resource r.Route("/articles", func(r chi.Router) { r.With(paginate).Get("/", listArticles) // GET /articles r.With(paginate).Get("/{month}-{day}-{year}", listArticlesByDate) // GET /articles/01-16-2017

r.Post("/", createArticle)                                        // POST /articles
r.Get("/search", searchArticles)                                  // GET /articles/search

// Regexp url parameters:
r.Get("/{articleSlug:[a-z-]+}", getArticleBySlug)                // GET /articles/home-is-toronto

// Subrouters:
r.Route("/{articleID}", func(r chi.Router) {
  r.Get("/", getArticle)                                          // GET /articles/123
  r.Put("/", updateArticle)                                       // PUT /articles/123
  r.Delete("/", deleteArticle)                                    // DELETE /articles/123


// Mount the admin sub-router r.Mount("/admin", adminRouter())

http.ListenAndServe(":3333", r) }

func ArticleCtx(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { articleID := chi.URLParam(r, "articleID") article, err := dbGetArticle(articleID) if err != nil { http.Error(w, http.StatusText(404), 404) return } ctx := context.WithValue(r.Context(), "article", article) next.ServeHTTP(w, r.WithContext(ctx)) }) }

func getArticle(w http.ResponseWriter, r *http.Request) { ctx := r.Context() article, ok := ctx.Value("article").(*Article) if !ok { http.Error(w, http.StatusText(422), 422) return } w.Write([]byte(fmt.Sprintf("title:%s", article.Title))) }

// A completely separate router for administrator routes func adminRouter() http.Handler { r := chi.NewRouter() r.Use(AdminOnly) r.Get("/", adminIndex) r.Get("/accounts", adminListAccounts) return r }

func AdminOnly(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() perm, ok := ctx.Value("acl.permission").(YourPermissionType) if !ok || !perm.IsAdmin() { http.Error(w, http.StatusText(403), 403) return } next.ServeHTTP(w, r) }) }

Router interface

chi's router is based on a kind of Patricia Radix trie. The router is fully compatible with


Built on top of the tree is the

// Router consisting of the core routing methods used by chi's Mux,
// using only the standard net/http.
type Router interface {

// Use appends one or more middlewares onto the Router stack.
Use(middlewares ...func(http.Handler) http.Handler)

// With adds inline middlewares for an endpoint handler.
With(middlewares ...func(http.Handler) http.Handler) Router

// Group adds a new inline-Router along the current routing
// path, with a fresh middleware stack for the inline-Router.
Group(fn func(r Router)) Router

// Route mounts a sub-Router along a `pattern`` string.
Route(pattern string, fn func(r Router)) Router

// Mount attaches another http.Handler along ./pattern/*
Mount(pattern string, h http.Handler)

// Handle and HandleFunc adds routes for `pattern` that matches
// all HTTP methods.
Handle(pattern string, h http.Handler)
HandleFunc(pattern string, h http.HandlerFunc)

// Method and MethodFunc adds routes for `pattern` that matches
// the `method` HTTP method.
Method(method, pattern string, h http.Handler)
MethodFunc(method, pattern string, h http.HandlerFunc)

// HTTP-method routing along `pattern`
Connect(pattern string, h http.HandlerFunc)
Delete(pattern string, h http.HandlerFunc)
Get(pattern string, h http.HandlerFunc)
Head(pattern string, h http.HandlerFunc)
Options(pattern string, h http.HandlerFunc)
Patch(pattern string, h http.HandlerFunc)
Post(pattern string, h http.HandlerFunc)
Put(pattern string, h http.HandlerFunc)
Trace(pattern string, h http.HandlerFunc)

// NotFound defines a handler to respond whenever a route could
// not be found.
NotFound(h http.HandlerFunc)

// MethodNotAllowed defines a handler to respond whenever a method is
// not allowed.
MethodNotAllowed(h http.HandlerFunc)


// Routes interface adds two methods for router traversal, which is also // used by the package to generate documentation for Routers. type Routes interface { // Routes returns the routing tree in an easily traversable structure. Routes() []Route

// Middlewares returns the list of middlewares in use by the router.
Middlewares() Middlewares

// Match searches the routing tree for a handler that matches
// the method/path - similar to routing a http request, but without
// executing the handler thereafter.
Match(rctx *Context, method, path string) bool


Each routing method accepts a URL

and chain of
. The URL pattern supports named params (ie.
) and wildcards (ie.
). URL parameters can be fetched at runtime by calling
chi.URLParam(r, "userID")
for named parameters and
chi.URLParam(r, "*")
for a wildcard parameter.

Middleware handlers

chi's middlewares are just stdlib net/http middleware handlers. There is nothing special about them, which means the router and all the tooling is designed to be compatible and friendly with any middleware in the community. This offers much better extensibility and reuse of packages and is at the heart of chi's purpose.

Here is an example of a standard net/http middleware where we assign a context key

the value of
. This middleware sets a hypothetical user identifier on the request context and calls the next handler in the chain.
// HTTP middleware setting a value on the request context
func MyMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // create new context from `r` request context, and assign key `"user"`
    // to value of `"123"`
    ctx := context.WithValue(r.Context(), "user", "123")

// call the next handler in the chain, passing the response writer and
// the updated request object with the new context value.
// note: context.Context values are nested, so any previously set
// values will be accessible as well, and the new `"user"` key
// will be accessible from this point forward.
next.ServeHTTP(w, r.WithContext(ctx))

}) }

Request handlers

chi uses standard net/http request handlers. This little snippet is an example of a http.Handler func that reads a user identifier from the request context - hypothetically, identifying the user sending an authenticated request, validated+set by a previous middleware handler.

// HTTP handler accessing data from the request context.
func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
  // here we read from the request context and fetch out `"user"` key set in
  // the MyMiddleware example above.
  user := r.Context().Value("user").(string)

// respond to the client w.Write([]byte(fmt.Sprintf("hi %s", user))) }

URL parameters

chi's router parses and stores URL parameters right onto the request context. Here is an example of how to access URL params in your net/http handlers. And of course, middlewares are able to access the same information.

// HTTP handler accessing the url routing parameters.
func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
  // fetch the url parameter `"userID"` from the request of a matching
  // routing pattern. An example routing pattern could be: /users/{userID}
  userID := chi.URLParam(r, "userID")

// fetch "key" from the request context ctx := r.Context() key := ctx.Value("key").(string)

// respond to the client w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key))) }


chi comes equipped with an optional

package, providing a suite of standard
middlewares. Please note, any middleware in the ecosystem that is also compatible with
can be used with chi's mux.

Core middlewares

| chi/middleware Handler | description | | :--------------------- | :---------------------------------------------------------------------- | | AllowContentEncoding | Enforces a whitelist of request Content-Encoding headers | | AllowContentType | Explicit whitelist of accepted request Content-Types | | BasicAuth | Basic HTTP authentication | | Compress | Gzip compression for clients that accept compressed responses | | ContentCharset | Ensure charset for Content-Type request headers | | CleanPath | Clean double slashes from request path | | GetHead | Automatically route undefined HEAD requests to GET handlers | | Heartbeat | Monitoring endpoint to check the servers pulse | | Logger | Logs the start and end of each request with the elapsed processing time | | NoCache | Sets response headers to prevent clients from caching | | Profiler | Easily attach net/http/pprof to your routers | | RealIP | Sets a http.Request's RemoteAddr to either X-Real-IP or X-Forwarded-For | | Recoverer | Gracefully absorb panics and prints the stack trace | | RequestID | Injects a request ID into the context of each request | | RedirectSlashes | Redirect slashes on routing paths | | RouteHeaders | Route handling for request headers | | SetHeader | Short-hand middleware to set a response header key/value | | StripSlashes | Strip slashes on routing paths | | Throttle | Puts a ceiling on the number of concurrent requests | | Timeout | Signals to the request context when the timeout deadline is reached | | URLFormat | Parse extension from url and put it on request context |

| WithValue | Short-hand middleware to set a key/value on the request context |

Extra middlewares & packages

Please see for additional packages.

| package | description | |:---------------------------------------------------|:------------------------------------------------------------- | cors | Cross-origin resource sharing (CORS) | | docgen | Print chi.Router routes at runtime | | jwtauth | JWT authentication | | hostrouter | Domain/host based request routing | | httplog | Small but powerful structured HTTP request logging | | httprate | HTTP request rate limiter | | httptracer | HTTP request performance tracing library | | httpvcr | Write deterministic tests for external sources |

| stampede | HTTP request coalescer |


is a tiny pkg that provides simple interface to signal context across call stacks and goroutines. It was originally written by Sameer Ajmani and is available in stdlib since go1.7.

Learn more at

and.. * Docs: * Source:


The benchmark suite:

Results as of Nov 29, 2020 with Go 1.15.5 on Linux AMD 3950x

BenchmarkChi_Param              3075895         384 ns/op         400 B/op      2 allocs/op
BenchmarkChi_Param5             2116603         566 ns/op         400 B/op      2 allocs/op
BenchmarkChi_Param20             964117        1227 ns/op         400 B/op      2 allocs/op
BenchmarkChi_ParamWrite         2863413         420 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GithubStatic       3045488         395 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GithubParam        2204115         540 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GithubAll            10000      113811 ns/op       81203 B/op    406 allocs/op
BenchmarkChi_GPlusStatic        3337485         359 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GPlusParam         2825853         423 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GPlus2Params       2471697         483 ns/op         400 B/op      2 allocs/op
BenchmarkChi_GPlusAll            194220        5950 ns/op        5200 B/op     26 allocs/op
BenchmarkChi_ParseStatic        3365324         356 ns/op         400 B/op      2 allocs/op
BenchmarkChi_ParseParam         2976614         404 ns/op         400 B/op      2 allocs/op
BenchmarkChi_Parse2Params       2638084         439 ns/op         400 B/op      2 allocs/op
BenchmarkChi_ParseAll            109567       11295 ns/op       10400 B/op     52 allocs/op
BenchmarkChi_StaticAll            16846       71308 ns/op       62802 B/op    314 allocs/op

Comparison with other routers:

NOTE: the allocs in the benchmark above are from the calls to http.Request's

method that clones the http.Request, sets the
on the duplicated (alloc'd) request and returns it the new request object. This is just how setting context on a request in Go works.


  • Carl Jackson for
    • Parts of chi's thinking comes from goji, and chi's middleware package sources from goji.
  • Armon Dadgar for
  • Contributions: @VojtechVitek

We'll be more than happy to see your contributions!

Beyond REST

chi is just a http router that lets you decompose request handling into many smaller layers. Many companies use chi to write REST services for their public APIs. But, REST is just a convention for managing state via HTTP, and there's a lot of other pieces required to write a complete client-server system or network of microservices.

Looking beyond REST, I also recommend some newer works in the field: * webrpc - Web-focused RPC client+server framework with code-gen * gRPC - Google's RPC framework via protobufs * graphql - Declarative query language * NATS - lightweight pub-sub


Copyright (c) 2015-present Peter Kieltyka

Licensed under MIT License

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.