🧠 Context

The Ctx struct represents the Context which hold the HTTP request and response. It has methods for the request query string, parameters, body, HTTP headers, and so on.
Accepts
Checks, if the specified extensions or content types are acceptable.
Based on the request’s Accept HTTP header.
Signature
func (c *Ctx) Accepts(offers ...string)          string
func (c *Ctx) AcceptsCharsets(offers ...string)  string
func (c *Ctx) AcceptsEncodings(offers ...string) string
func (c *Ctx) AcceptsLanguages(offers ...string) string
Example
// Accept: text/*, application/json
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Accepts("html")             // "html"
  c.Accepts("text/html")        // "text/html"
  c.Accepts("json", "text")     // "json"
  c.Accepts("application/json") // "application/json"
  c.Accepts("image/png")        // ""
  c.Accepts("png")              // ""
  // ...
})
Fiber provides similar functions for the other accept headers.
// Accept-Charset: utf-8, iso-8859-1;q=0.2
// Accept-Encoding: gzip, compress;q=0.2
// Accept-Language: en;q=0.8, nl, ru
​
app.Get("/", func(c *fiber.Ctx) error {
  c.AcceptsCharsets("utf-16", "iso-8859-1") 
  // "iso-8859-1"
​
  c.AcceptsEncodings("compress", "br") 
  // "compress"
​
  c.AcceptsLanguages("pt", "nl", "ru") 
  // "nl"
  // ...
})
Append
Appends the specified value to the HTTP response header field.
If the header is not already set, it creates the header with the specified value.
Signature
func (c *Ctx) Append(field string, values ...string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Append("Link", "http://google.com", "http://localhost")
  // => Link: http://localhost, http://google.com
​
  c.Append("Link", "Test")
  // => Link: http://localhost, http://google.com, Test
​
  // ...
})
Attachment
Sets the HTTP response Content-Disposition header field to attachment.
Signature
func (c *Ctx) Attachment(filename ...string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Attachment()
  // => Content-Disposition: attachment
​
  c.Attachment("./upload/images/logo.png")
  // => Content-Disposition: attachment; filename="logo.png"
  // => Content-Type: image/png
​
  // ...
})
App
Returns the *App reference so you could easily access all application settings.
Signature
func (c *Ctx) App() *App
Example
app.Get("/stack", func(c *fiber.Ctx) error {
  return c.JSON(c.App().Stack())
})
BaseURL
Returns the base URL (protocol + host) as a string.
Signature
func (c *Ctx) BaseURL() string
Example
// GET https://example.com/page#chapter-1
​
app.Get("/", func(c *fiber.Ctx) error {
  c.BaseURL() // https://example.com
  // ...
})
Body
Returns the raw request body.
Signature
func (c *Ctx) Body() []byte
Example
// curl -X POST http://localhost:8080 -d user=john
​
app.Post("/", func(c *fiber.Ctx) error {
  // Get raw body from POST request:
  return c.Send(c.Body()) // []byte("user=john")
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
BodyParser
Binds the request body to a struct. BodyParser supports decoding query parameters and the following content types based on the Content-Type header:
application/json
application/xml
application/x-www-form-urlencoded
multipart/form-data
Signature
func (c *Ctx) BodyParser(out interface{}) error
Example
// Field names should start with an uppercase letter
type Person struct {
    Name string `json:"name" xml:"name" form:"name"`
    Pass string `json:"pass" xml:"pass" form:"pass"`
}
​
app.Post("/", func(c *fiber.Ctx) error {
        p := new(Person)
​
        if err := c.BodyParser(p); err != nil {
            return err
        }
​
        log.Println(p.Name) // john
        log.Println(p.Pass) // doe
​
        // ...
})
​
// Run tests with the following curl commands
​
// curl -X POST -H "Content-Type: application/json" --data "{\"name\":\"john\",\"pass\":\"doe\"}" localhost:3000
​
// curl -X POST -H "Content-Type: application/xml" --data "<login><name>john</name><pass>doe</pass></login>" localhost:3000
​
// curl -X POST -H "Content-Type: application/x-www-form-urlencoded" --data "name=john&pass=doe" localhost:3000
​
// curl -X POST -F name=john -F pass=doe http://localhost:3000
​
// curl -X POST "http://localhost:3000/?name=john&pass=doe"
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
ClearCookie
Expire a client cookie (or all cookies if left empty)
Signature
func (c *Ctx) ClearCookie(key ...string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  // Clears all cookies:
  c.ClearCookie()
​
  // Expire specific cookie by name:
  c.ClearCookie("user")
​
  // Expire multiple cookies by names:
  c.ClearCookie("token", "session", "track_id", "version")
  // ...
})
Web browsers and other compliant clients will only clear the cookie if the given options are identical to those when creating the cookie, excluding expires and maxAge. ClearCookie will not set these values for you - a technique similar to the one shown below should be used to ensure your cookie is deleted.
Example
app.Get("/set", func(c *fiber.Ctx) error {
    c.Cookie(&fiber.Cookie{
        Name:     "token",
        Value:    "randomvalue",
        Expires:  time.Now().Add(24 * time.Hour),
        HTTPOnly: true,
        SameSite: "lax",
    })
​
    // ...
})
​
app.Get("/delete", func(c *fiber.Ctx) error {
    c.Cookie(&fiber.Cookie{
        Name:     "token",
        // Set expiry date to the past
        Expires:  time.Now().Add(-(time.Hour * 2)),
        HTTPOnly: true,
        SameSite: "lax",
    })
​
    // ...
})
Context
Returns *fasthttp.RequestCtx that is compatible with the context.Context interface that requires a deadline, a cancellation signal, and other values across API boundaries.
Signature
func (c *Ctx) Context() *fasthttp.RequestCtx
Please read the Fasthttp Documentation for more information.
Cookie
Set cookie
Signature
func (c *Ctx) Cookie(cookie *Cookie)
type Cookie struct {
    Name     string    `json:"name"`
    Value    string    `json:"value"`
    Path     string    `json:"path"`
    Domain   string    `json:"domain"`
    MaxAge   int       `json:"max_age"`
    Expires  time.Time `json:"expires"`
    Secure   bool      `json:"secure"`
    HTTPOnly bool      `json:"http_only"`
    SameSite string    `json:"same_site"`
}
Example
app.Get("/", func(c *fiber.Ctx) error {
  // Create cookie
  cookie := new(fiber.Cookie)
  cookie.Name = "john"
  cookie.Value = "doe"
  cookie.Expires = time.Now().Add(24 * time.Hour)
​
  // Set cookie
  c.Cookie(cookie)
  // ...
})
Cookies
Get cookie value by key, you could pass an optional default value that will be returned if the cookie key does not exist.
Signatures
func (c *Ctx) Cookies(key string, defaultValue ...string) string
Example
app.Get("/", func(c *fiber.Ctx) error {
  // Get cookie by key:
  c.Cookies("name")         // "john"
  c.Cookies("empty", "doe") // "doe"
  // ...
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
Download
Transfers the file from path as an attachment.
Typically, browsers will prompt the user to download. By default, the Content-Disposition header filename= parameter is the file path (this typically appears in the browser dialog).
Override this default with the filename parameter.
Signature
func (c *Ctx) Download(file string, filename ...string) error
Example
app.Get("/", func(c *fiber.Ctx) error {
  return c.Download("./files/report-12345.pdf");
  // => Download report-12345.pdf
​
  return c.Download("./files/report-12345.pdf", "report.pdf");
  // => Download report.pdf
})
Request
Request return the *fasthttp.Request pointer
Signature
Signature
func (c *Ctx) Request() *fasthttp.Request
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Request().Header.Method()
  // => []byte("GET")
})
Response
Response return the *fasthttp.Response pointer
Signature
Signature
func (c *Ctx) Response() *fasthttp.Response
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Response().Write([]byte("Hello, World!"))
  // => "Hello, World!"
})
Format
Performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format.
If the header is not specified or there is no proper format, text/plain is used.
Signature
func (c *Ctx) Format(body interface{}) error
Example
app.Get("/", func(c *fiber.Ctx) error {
  // Accept: text/plain
  c.Format("Hello, World!")
  // => Hello, World!
​
  // Accept: text/html
  c.Format("Hello, World!")
  // => <p>Hello, World!</p>
​
  // Accept: application/json
  c.Format("Hello, World!")
  // => "Hello, World!"
  // ..
})
FormFile
MultipartForm files can be retrieved by name, the first file from the given key is returned.
Signature
func (c *Ctx) FormFile(key string) (*multipart.FileHeader, error)
Example
app.Post("/", func(c *fiber.Ctx) error {
  // Get first file from form field "document":
  file, err := c.FormFile("document")
​
  // Save file to root directory:
  return c.SaveFile(file, fmt.Sprintf("./%s", file.Filename))
})
FormValue
Any form values can be retrieved by name, the first value from the given key is returned.
Signature
func (c *Ctx) FormValue(key string, defaultValue ...string) string
Example
app.Post("/", func(c *fiber.Ctx) error {
  // Get first value from form field "name":
  c.FormValue("name")
  // => "john" or "" if not exist
​
  // ..
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
Fresh
​https://expressjs.com/en/4x/api.html#req.fresh​
Signature
func (c *Ctx) Fresh() bool
Get
Returns the HTTP request header specified by the field.
The match is case-insensitive.
Signature
func (c *Ctx) Get(key string, defaultValue ...string) string
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Get("Content-Type")       // "text/plain"
  c.Get("CoNtEnT-TypE")       // "text/plain"
  c.Get("something", "john")  // "john"
  // ..
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
GetRespHeader
Returns the HTTP response header specified by the field.
The match is case-insensitive.
Signature
func (c *Ctx) GetRespHeader(key string, defaultValue ...string) string
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.GetRespHeader("X-Request-Id")       // "8d7ad5e3-aaf3-450b-a241-2beb887efd54"
  c.GetRespHeader("Content-Type")       // "text/plain"
  c.GetRespHeader("something", "john")  // "john"
  // ..
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
Hostname
Returns the hostname derived from the Host HTTP header.
Signature
func (c *Ctx) Hostname() string
Example
// GET http://google.com/search
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Hostname() // "google.com"
​
  // ...
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
IP
Returns the remote IP address of the request.
Signature
func (c *Ctx) IP() string
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.IP() // "127.0.0.1"
​
  // ...
})
IPs
Returns an array of IP addresses specified in the X-Forwarded-For request header.
Signature
func (c *Ctx) IPs() []string
Example
// X-Forwarded-For: proxy1, 127.0.0.1, proxy3
​
app.Get("/", func(c *fiber.Ctx) error {
  c.IPs() // ["proxy1", "127.0.0.1", "proxy3"]
​
  // ...
})
Is
Returns the matching content type, if the incoming request’s Content-Type HTTP header field matches the MIME type specified by the type parameter.
If the request has no body, it returns false.
Signature
func (c *Ctx) Is(extension string) bool
Example
// Content-Type: text/html; charset=utf-8
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Is("html")  // true
  c.Is(".html") // true
  c.Is("json")  // false
​
  // ...
})
JSON
Converts any interface or string to JSON using the segmentio/encoding package.
JSON also sets the content header to application/json.
Signature
func (c *Ctx) JSON(data interface{}) error
Example
type SomeStruct struct {
  Name string
  Age  uint8
}
​
app.Get("/json", func(c *fiber.Ctx) error {
  // Create data struct:
  data := SomeStruct{
    Name: "Grame",
    Age:  20,
  }
​
  return c.JSON(data)
  // => Content-Type: application/json
  // => "{"Name": "Grame", "Age": 20}"
​
  return c.JSON(fiber.Map{
    "name": "Grame",
    "age": 20,
  })
  // => Content-Type: application/json
  // => "{"name": "Grame", "age": 20}"
})
JSONP
Sends a JSON response with JSONP support. This method is identical to JSON, except that it opts-in to JSONP callback support. By default, the callback name is simply callback.
Override this by passing a named string in the method.
Signature
func (c *Ctx) JSONP(data interface{}, callback ...string) error
Example
type SomeStruct struct {
  name string
  age  uint8
}
​
app.Get("/", func(c *fiber.Ctx) error {
  // Create data struct:
  data := SomeStruct{
    name: "Grame",
    age:  20,
  }
​
  return c.JSONP(data)
  // => callback({"name": "Grame", "age": 20})
​
  return c.JSONP(data, "customFunc")
  // => customFunc({"name": "Grame", "age": 20})
})
Links
Joins the links followed by the property to populate the response’s Link HTTP header field.
Signature
func (c *Ctx) Links(link ...string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Links(
    "http://api.example.com/users?page=2", "next",
    "http://api.example.com/users?page=5", "last",
  )
  // Link: <http://api.example.com/users?page=2>; rel="next",
  //       <http://api.example.com/users?page=5>; rel="last"
​
  // ...
})
Locals
A method that stores variables scoped to the request and, therefore, are available only to the routes that match the request.
This is useful if you want to pass some specific data to the next middleware.
Signature
func (c *Ctx) Locals(key string, value ...interface{}) interface{}
Example
app.Use(func(c *fiber.Ctx) error {
  c.Locals("user", "admin")
  return c.Next()
})
​
app.Get("/admin", func(c *fiber.Ctx) error {
  if c.Locals("user") == "admin" {
    return c.Status(fiber.StatusOK).SendString("Welcome, admin!")
  }
  return c.SendStatus(fiber.StatusForbidden)
​
})
Location
Sets the response Location HTTP header to the specified path parameter.
Signature
func (c *Ctx) Location(path string)
Example
app.Post("/", func(c *fiber.Ctx) error {
  return c.Location("http://example.com")
​
  return c.Location("/foo/bar")
})
Method
Returns a string corresponding to the HTTP method of the request: GET, POST, PUT, and so on.
Optionally, you could override the method by passing a string.
Signature
func (c *Ctx) Method(override ...string) string
Example
app.Post("/", func(c *fiber.Ctx) error {
  c.Method() // "POST"
​
  c.Method("GET")
  c.Method() // GET
​
  // ...
})
MultipartForm
To access multipart form entries, you can parse the binary with MultipartForm(). This returns a map[string][]string, so given a key, the value will be a string slice.
Signature
func (c *Ctx) MultipartForm() (*multipart.Form, error)
Example
app.Post("/", func(c *fiber.Ctx) error {
  // Parse the multipart form:
  if form, err := c.MultipartForm(); err == nil {
    // => *multipart.Form
​
    if token := form.Value["token"]; len(token) > 0 {
      // Get key value:
      fmt.Println(token[0])
    }
​
    // Get all files from "documents" key:
    files := form.File["documents"]
    // => []*multipart.FileHeader
​
    // Loop through files:
    for _, file := range files {
      fmt.Println(file.Filename, file.Size, file.Header["Content-Type"][0])
      // => "tutorial.pdf" 360641 "application/pdf"
​
      // Save the files to disk:
      if err := c.SaveFile(file, fmt.Sprintf("./%s", file.Filename)); err != nil {
        return err
      }
    }
  }
​
  return err
})
Next
When Next is called, it executes the next method in the stack that matches the current route. You can pass an error struct within the method that will end the chaining and call the error handler.
Signature
func (c *Ctx) Next() error
Example
app.Get("/", func(c *fiber.Ctx) error {
  fmt.Println("1st route!")
  return c.Next()
})
​
app.Get("*", func(c *fiber.Ctx) error {
  fmt.Println("2nd route!")
  return c.Next()
})
​
app.Get("/", func(c *fiber.Ctx) error {
  fmt.Println("3rd route!")
  return c.SendString("Hello, World!")
})
OriginalURL
Returns the original request URL.
Signature
func (c *Ctx) OriginalURL() string
Example
// GET http://example.com/search?q=something
​
app.Get("/", func(c *fiber.Ctx) error {
  c.OriginalURL() // "/search?q=something"
​
  // ...
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
Params
Method can be used to get the route parameters, you could pass an optional default value that will be returned if the param key does not exist.
Defaults to empty string (""), if the param doesn't exist.
Signature
func (c *Ctx) Params(key string, defaultValue ...string) string
Example
// GET http://example.com/user/fenny
app.Get("/user/:name", func(c *fiber.Ctx) error {
  c.Params("name") // "fenny"
​
  // ...
})
​
// GET http://example.com/user/fenny/123
app.Get("/user/*", func(c *fiber.Ctx) error {
  c.Params("*")  // "fenny/123"
  c.Params("*1") // "fenny/123"
​
  // ...
})
Unnamed route parameters(*, +) can be fetched by the character and the counter in the route.
Example
// ROUTE: /v1/*/shop/*
// GET:   /v1/brand/4/shop/blue/xs
c.Params("*1")  // "brand/4"
c.Params("*2")  // "blue/xs"
For reasons of downward compatibility, the first parameter segment for the parameter character can also be accessed without the counter.
Example
app.Get("/v1/*/shop/*", func(c *fiber.Ctx) error {
  c.Params("*") // outputs the values of the first wildcard segment
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
ParamsInt
Method can be used to get an integer from the route parameters. Please note if that parameter is not in the request, zero will be returned. If the parameter is NOT a number, zero and an error will be returned
Defaults to empty string (""), if the param doesn't exist.
Signature
func (c *Ctx) Params(key string) (int, error)
Example
// GET http://example.com/user/123
app.Get("/user/:id", func(c *fiber.Ctx) error {
  id, err := c.ParamsInt("id") // int 123 and no error
​
  // ...
})
This method is equivalent of using atoi with ctx.Params
Path
Contains the path part of the request URL. Optionally, you could override the path by passing a string.
Signature
func (c *Ctx) Path(override ...string) string
Example
// GET http://example.com/users?sort=desc
​
app.Get("/users", func(c *fiber.Ctx) error {
  c.Path() // "/users"
​
  c.Path("/john")
  c.Path() // "/john"
​
  // ...
})
Protocol
Contains the request protocol string: http or https for TLS requests.
Signature
func (c *Ctx) Protocol() string
Example
// GET http://example.com
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Protocol() // "http"
​
  // ...
})
Query
This property is an object containing a property for each query string parameter in the route, you could pass an optional default value that will be returned if the query key does not exist.
If there is no query string, it returns an empty string.
Signature
func (c *Ctx) Query(key string, defaultValue ...string) string
Example
// GET http://example.com/shoes?order=desc&brand=nike
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Query("order")         // "desc"
  c.Query("brand")         // "nike"
  c.Query("empty", "nike") // "nike"
​
  // ...
})
Returned value is only valid within the handler. Do not store any references.
Make copies or use the Immutable setting instead. Read more...​
QueryParser
This method is similar to BodyParser, but for query parameters.
Signature
func (c *Ctx) QueryParser(out interface{}) error
Example
// Field names should start with an uppercase letter
type Person struct {
    Name     string     `query:"name"`
    Pass     string     `query:"pass"`
    Products []string   `query:"products"`
}
​
app.Get("/", func(c *fiber.Ctx) error {
        p := new(Person)
​
        if err := c.QueryParser(p); err != nil {
            return err
        }
​
        log.Println(p.Name)     // john
        log.Println(p.Pass)     // doe
        log.Println(p.Products) // [shoe, hat]
​
        // ...
})
// Run tests with the following curl command
​
// curl "http://localhost:3000/?name=john&pass=doe&products=shoe,hat"
Range
A struct containing the type and a slice of ranges will be returned.
Signature
func (c *Ctx) Range(size int) (Range, error)
Example
// Range: bytes=500-700, 700-900
app.Get("/", func(c *fiber.Ctx) error {
  b := c.Range(1000)
  if b.Type == "bytes" {
      for r := range r.Ranges {
      fmt.Println(r)
      // [500, 700]
    }
  }
})
Redirect
Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an HTTP status code.
If not specified, status defaults to 302 Found.
Signature
func (c *Ctx) Redirect(location string, status ...int) error
Example
app.Get("/coffee", func(c *fiber.Ctx) error {
  return c.Redirect("/teapot")
})
​
app.Get("/teapot", func(c *fiber.Ctx) error {
  return c.Status(fiber.StatusTeapot).Send("🍵 short and stout 🍵")
})
More examples
app.Get("/", func(c *fiber.Ctx) error {
  return c.Redirect("/foo/bar")
  return c.Redirect("../login")
  return c.Redirect("http://example.com")
  return c.Redirect("http://example.com", 301)
})
Render
Renders a view with data and sends a text/html response. By default Render uses the default Go Template engine. If you want to use another View engine, please take a look at our Template middleware.
Signature
func (c *Ctx) Render(name string, bind interface{}, layouts ...string) error
Route
Returns the matched Route struct.
Signature
func (c *Ctx) Route() *Route
Example
// http://localhost:8080/hello
​
​
app.Get("/hello/:name", func(c *fiber.Ctx) error {
  r := c.Route()
  fmt.Println(r.Method, r.Path, r.Params, r.Handlers)
  // GET /hello/:name handler [name] 
​
  // ...
})
Do not rely on c.Route() in middlewares before calling c.Next() - c.Route() returns the last executed route.
Example
func MyMiddleware() fiber.Handler {
  return func(c *fiber.Ctx) error {
    beforeNext := c.Route().Path // Will be '/'
    err := c.Next()
    afterNext := c.Route().Path // Will be '/hello/:name'
    return err
  }
}
SaveFile
Method is used to save any multipart file to disk.
Signature
func (c *Ctx) SaveFile(fh *multipart.FileHeader, path string) error
Example
app.Post("/", func(c *fiber.Ctx) error {
  // Parse the multipart form:
  if form, err := c.MultipartForm(); err == nil {
    // => *multipart.Form
​
    // Get all files from "documents" key:
    files := form.File["documents"]
    // => []*multipart.FileHeader
​
    // Loop through files:
    for _, file := range files {
      fmt.Println(file.Filename, file.Size, file.Header["Content-Type"][0])
      // => "tutorial.pdf" 360641 "application/pdf"
​
      // Save the files to disk:
      if err := c.SaveFile(file, fmt.Sprintf("./%s", file.Filename)); err != nil {
        return err
      }
    }
    return err
  }
})
Secure
A boolean property that is true , if a TLS connection is established.
Signature
func (c *Ctx) Secure() bool
Example
// Secure() method is equivalent to:
c.Protocol() == "https"
Send
Sets the HTTP response body.
Signature
func (c *Ctx) Send(body []byte) error
Example
app.Get("/", func(c *fiber.Ctx) error {
  return c.Send([]byte("Hello, World!")) // => "Hello, World!"
})
Fiber also provides SendString and SendStream methods for raw inputs.
Use this if you don't need type assertion, recommended for faster performance.
Signature
func (c *Ctx) SendString(body string) error
func (c *Ctx) SendStream(stream io.Reader, size ...int) error
Example
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Hello, World!")
  // => "Hello, World!"
​
  return c.SendStream(bytes.NewReader([]byte("Hello, World!")))
  // => "Hello, World!"
})
SendFile
Transfers the file from the given path. Sets the Content-Type response HTTP header field based on the filenames extension.
Method doesn´t use gzipping by default, set it to true to enable.
Signature
func (c *Ctx) SendFile(file string, compress ...bool) error
Example
app.Get("/not-found", func(c *fiber.Ctx) error {
  return c.SendFile("./public/404.html");
​
  // Disable compression
  return c.SendFile("./static/index.html", false);
})
SendStatus
Sets the status code and the correct status message in the body, if the response body is empty.
You can find all used status codes and messages here.
Signature
func (c *Ctx) SendStatus(status int) error
Example
app.Get("/not-found", func(c *fiber.Ctx) error {
  return c.SendStatus(415)
  // => 415 "Unsupported Media Type"
​
  c.SendString("Hello, World!")
  return c.SendStatus(415)
  // => 415 "Hello, World!"
})
Set
Sets the response’s HTTP header field to the specified key, value.
Signature
func (c *Ctx) Set(key string, val string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Set("Content-Type", "text/plain")
  // => "Content-type: text/plain"
​
  // ...
})
SetUserContext
Sets the user specified implementation for context interface.
Signature
func (c *Ctx) SetUserContext(ctx context.Context)
Example
app.Get("/", func(c *fiber.Ctx) error {
  ctx := context.Background()
  c.SetUserContext(ctx)
  // Here ctx could be any context implementation
​
  // ...
})
Stale
​https://expressjs.com/en/4x/api.html#req.stale​
Signature
func (c *Ctx) Stale() bool
Status
Sets the HTTP status for the response.
Method is a chainable.
Signature
func (c *Ctx) Status(status int) *Ctx
Example
app.Get("/fiber", func(c *fiber.Ctx) error {
  c.Status(fiber.StatusOK)
  return nil
}
​
app.Get("/hello", func(c *fiber.Ctx) error {
  return c.Status(fiber.StatusBadRequest).SendString("Bad Request")
}
​
app.Get("/world", func(c *fiber.Ctx) error {
  return c.Status(fiber.StatusNotFound).SendFile("./public/gopher.png")
})
Subdomains
Returns a string slice of subdomains in the domain name of the request.
The application property subdomain offset, which defaults to 2, is used for determining the beginning of the subdomain segments.
Signature
func (c *Ctx) Subdomains(offset ...int) []string
Example
// Host: "tobi.ferrets.example.com"
​
app.Get("/", func(c *fiber.Ctx) error {
  c.Subdomains()  // ["ferrets", "tobi"]
  c.Subdomains(1) // ["tobi"]
​
  // ...
})
Type
Sets the Content-Type HTTP header to the MIME type listed here specified by the file extension.
Signature
func (c *Ctx) Type(ext string, charset ...string) *Ctx
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Type(".html") // => "text/html"
  c.Type("html")  // => "text/html"
  c.Type("png")   // => "image/png"
​
  c.Type("json", "utf-8")  // => "application/json; charset=utf-8"
​
  // ...
})
UserContext
UserContext returns a context implementation that was set by user earlier or returns a non-nil, empty context, if it was not set earlier.
Signature
func (c *Ctx) UserContext() context.Context
Example
app.Get("/", func(c *fiber.Ctx) error {
  ctx := c.UserContext()
  // ctx is context implementation set by user
​
  // ...
})
Vary
Adds the given header field to the Vary response header. This will append the header, if not already listed, otherwise leaves it listed in the current location.
Multiple fields are allowed.
Signature
func (c *Ctx) Vary(fields ...string)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Vary("Origin")     // => Vary: Origin
  c.Vary("User-Agent") // => Vary: Origin, User-Agent
​
  // No duplicates
  c.Vary("Origin") // => Vary: Origin, User-Agent
​
  c.Vary("Accept-Encoding", "Accept")
  // => Vary: Origin, User-Agent, Accept-Encoding, Accept
​
  // ...
})
Write
Write adopts the Writer interface
Signature
func (c *Ctx) Write(p []byte) (n int, err error)
Example
app.Get("/", func(c *fiber.Ctx) error {
  c.Write([]byte("Hello, World!")) // => "Hello, World!"
​
  fmt.Fprintf(c, "%s\n", "Hello, World!") // "Hello, World!Hello, World!"
})
XHR
A Boolean property, that is true, if the request’s X-Requested-With header field is XMLHttpRequest, indicating that the request was issued by a client library (such as jQuery).
Signature
func (c *Ctx) XHR() bool
Example
// X-Requested-With: XMLHttpRequest
​
app.Get("/", func(c *fiber.Ctx) error {
  c.XHR() // true
​
  // ...
})
API - Previous
🚀 App
Next - API
🧬 Middleware
Last updated 4 weeks ago