Skip to main content
Version: Next

🧠 Ctx

Accepts​

Checks, if the specified extensions or content types are acceptable.

info

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/html, application/json; q=0.8, text/plain; q=0.5; charset="utf-8"

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("text/plain", "application/json") // "application/json", due to quality
c.Accepts("image/png") // ""
c.Accepts("png") // ""
// ...
})
Example 2
// Accept: text/html, text/*, application/json, */*; q=0

app.Get("/", func(c fiber.Ctx) error {
c.Accepts("text/plain", "application/json") // "application/json", due to specificity
c.Accepts("application/json", "text/html") // "text/html", due to first match
c.Accepts("image/png") // "", due to */* without q factor 0 is Not Acceptable
// ...
})

Media-Type parameters are supported.

Example 3
// Accept: text/plain, application/json; version=1; foo=bar

app.Get("/", func(c fiber.Ctx) error {
// Extra parameters in the accept are ignored
c.Accepts("text/plain;format=flowed") // "text/plain;format=flowed"

// An offer must contain all parameters present in the Accept type
c.Accepts("application/json") // ""

// Parameter order and capitalization does not matter. Quotes on values are stripped.
c.Accepts(`application/json;foo="bar";VERSION=1`) // "application/json;foo="bar";VERSION=1"
})
Example 4
// Accept: text/plain;format=flowed;q=0.9, text/plain
// i.e., "I prefer text/plain;format=flowed less than other forms of text/plain"
app.Get("/", func(c fiber.Ctx) error {
// Beware: the order in which offers are listed matters.
// Although the client specified they prefer not to receive format=flowed,
// the text/plain Accept matches with "text/plain;format=flowed" first, so it is returned.
c.Accepts("text/plain;format=flowed", "text/plain") // "text/plain;format=flowed"

// Here, things behave as expected:
c.Accepts("text/plain", "text/plain;format=flowed") // "text/plain"
})

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"
// ...
})

AllParams​

Params is used to get all route parameters. Using Params method to get params.

Signature
func (c Ctx) AllParams() map[string]string
Example
// GET http://example.com/user/fenny
app.Get("/user/:name", func(c fiber.Ctx) error {
c.AllParams() // "{"name": "fenny"}"

// ...
})

// GET http://example.com/user/fenny/123
app.Get("/user/*", func(c fiber.Ctx) error {
c.AllParams() // "{"*1": "fenny/123"}"

// ...
})

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())
})

Append​

Appends the specified value to the HTTP response header field.

caution

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

// ...
})

AutoFormat​

Performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format. The supported content types are text/html, text/plain, application/json, and application/xml. For more flexible content negotiation, use Format.

info

If the header is not specified or there is no proper format, text/plain is used.

Signature
func (c Ctx) AutoFormat(body any) error
Example
app.Get("/", func(c fiber.Ctx) error {
// Accept: text/plain
c.AutoFormat("Hello, World!")
// => Hello, World!

// Accept: text/html
c.AutoFormat("Hello, World!")
// => <p>Hello, World!</p>

type User struct {
Name string
}
user := User{"John Doe"}

// Accept: application/json
c.AutoFormat(user)
// => {"Name":"John Doe"}

// Accept: application/xml
c.AutoFormat(user)
// => <User><Name>John Doe</Name></User>
// ..
})

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
// ...
})

Bind​

Add vars to default view var map binding to template engine. Variables are read by the Render method and may be overwritten.

Signature
func (c Ctx) Bind(vars Map) error
Example
app.Use(func(c fiber.Ctx) error {
c.Bind(fiber.Map{
"Title": "Hello, World!",
})
})

app.Get("/", func(c fiber.Ctx) error {
return c.Render("xxx.tmpl", fiber.Map{}) // Render will use Title variable
})

BodyRaw​

Returns the raw request body.

Signature
func (c Ctx) BodyRaw() []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.BodyRaw()) // []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...

Body​

As per the header Content-Encoding, this method will try to perform a file decompression from the body bytes. In case no Content-Encoding header is sent, it will perform as BodyRaw.

Signature
func (c Ctx) Body() []byte
Example
// echo 'user=john' | gzip | curl -v -i --data-binary @- -H "Content-Encoding: gzip" http://localhost:8080

app.Post("/", func(c fiber.Ctx) error {
// Decompress body from POST request based on the Content-Encoding and return the raw content:
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.

It is important to specify the correct struct tag based on the content type to be parsed. For example, if you want to parse a JSON body with a field called Pass, you would use a struct field of json:"pass".

content-typestruct tag
application/x-www-form-urlencodedform
multipart/form-dataform
application/jsonjson
application/xmlxml
text/xmlxml
Signature
func (c Ctx) BodyParser(out any) 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")
// ...
})
caution

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",
})

// ...
})

ClientHelloInfo​

ClientHelloInfo contains information from a ClientHello message in order to guide application logic in the GetCertificate and GetConfigForClient callbacks. You can refer to the ClientHelloInfo struct documentation for more information on the returned struct.

Signature
func (c Ctx) ClientHelloInfo() *tls.ClientHelloInfo
Example
// GET http://example.com/hello
app.Get("/hello", func(c fiber.Ctx) error {
chi := c.ClientHelloInfo()
// ...
})

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
info

Please read the Fasthttp Documentation for more information.

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"`
SessionOnly bool `json:"session_only"`
}
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)
// ...
})

CookieParser​

This method is similar to BodyParser, but for cookie parameters. It is important to use the struct tag "cookie". For example, if you want to parse a cookie with a field called Age, you would use a struct field of cookie:"age".

Signature
func (c Ctx) CookieParser(out any) error
Example
// Field names should start with an uppercase letter
type Person struct {
Name string `cookie:"name"`
Age int `cookie:"age"`
Job bool `cookie:"job"`
}

app.Get("/", func(c fiber.Ctx) error {
p := new(Person)

if err := c.CookieParser(p); err != nil {
return err
}

log.Println(p.Name) // Joseph
log.Println(p.Age) // 23
log.Println(p.Job) // true
})
// Run tests with the following curl command
// curl.exe --cookie "name=Joseph; age=23; job=true" http://localhost:8000/

Cookies​

Get cookie value by key, you could pass an optional default value that will be returned if the cookie key does not exist.

Signature
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
})

Format​

Performs content-negotiation on the Accept HTTP header. It uses Accepts to select a proper format from the supplied offers. A default handler can be provided by setting the MediaType to "default". If no offers match and no default is provided, a 406 (Not Acceptable) response is sent. The Content-Type is automatically set when a handler is selected.

info

If the Accept header is not specified, the first handler will be used.

Signature
func (c Ctx) Format(handlers ...ResFmt) error
Example
// Accept: application/json => {"command":"eat","subject":"fruit"}
// Accept: text/plain => Eat Fruit!
// Accept: application/xml => Not Acceptable
app.Get("/no-default", func(c fiber.Ctx) error {
return c.Format(
fiber.ResFmt{"application/json", func(c fiber.Ctx) error {
return c.JSON(fiber.Map{
"command": "eat",
"subject": "fruit",
})
}},
fiber.ResFmt{"text/plain", func(c fiber.Ctx) error {
return c.SendString("Eat Fruit!")
}},
)
})

// Accept: application/json => {"command":"eat","subject":"fruit"}
// Accept: text/plain => Eat Fruit!
// Accept: application/xml => Eat Fruit!
app.Get("/default", func(c fiber.Ctx) error {
textHandler := func(c fiber.Ctx) error {
return c.SendString("Eat Fruit!")
}

handlers := []fiber.ResFmt{
{"application/json", func(c fiber.Ctx) error {
return c.JSON(fiber.Map{
"command": "eat",
"subject": "fruit",
})
}},
{"text/plain", textHandler},
{"default", textHandler},
}

return c.Format(handlers...)
})

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​

When the response is still fresh in the client's cache true is returned, otherwise false is returned to indicate that the client cache is now stale and the full response should be sent.

When a client sends the Cache-Control: no-cache request header to indicate an end-to-end reload request, Fresh will return false to make handling these requests transparent.

Read more on 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.

tip

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...

GetReqHeaders​

Returns the HTTP request headers as a map. Since a header can be set multiple times in a single request, the values of the map are slices of strings containing all the different values of the header.

Signature
func (c Ctx) GetReqHeaders() map[string][]string

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.

tip

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...

GetRespHeaders​

Returns the HTTP response headers as a map. Since a header can be set multiple times in a single request, the values of the map are slices of strings containing all the different values of the header.

Signature
func (c Ctx) GetRespHeaders() map[string][]string

Returned value is only valid within the handler. Do not store any references.
Make copies or use the
Immutable setting instead. Read more...

GetRouteURL​

Generates URLs to named routes, with parameters. URLs are relative, for example: "/user/1831"

Signature
func (c Ctx) GetRouteURL(routeName string, params Map) (string, error)
Example
app.Get("/", func(c fiber.Ctx) error {
return c.SendString("Home page")
}).Name("home")

app.Get("/user/:id", func(c fiber.Ctx) error {
return c.SendString(c.Params("id"))
}).Name("user.show")

app.Get("/test", func(c fiber.Ctx) error {
location, _ := c.GetRouteURL("user.show", fiber.Map{"id": 1})
return c.SendString(location)
})

// /test returns "/user/1"

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"

// ...
})

When registering the proxy request header in the fiber app, the ip address of the header is returned (Fiber configuration)

app := fiber.New(fiber.Config{
ProxyHeader: fiber.HeaderXForwardedFor,
})

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"]

// ...
})
caution

Improper use of the X-Forwarded-For header can be a security risk. For details, see the Security and privacy concerns section.

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.

info

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

// ...
})

IsFromLocal​

Returns true if request came from localhost

Signature
func (c Ctx) IsFromLocal() bool {
Example

app.Get("/", func(c fiber.Ctx) error {
// If request came from localhost, return true else return false
c.IsFromLocal()

// ...
})

JSON​

Converts any interface or string to JSON using the encoding/json package.

info

JSON also sets the content header to the ctype parameter. If no ctype is passed in, the header is set to application/json.

Signature
func (c Ctx) JSON(data any, ctype ...string) 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}"

return c.JSON(fiber.Map{
"type": "https://example.com/probs/out-of-credit",
"title": "You do not have enough credit.",
"status": 403,
"detail": "Your current balance is 30, but that costs 50.",
"instance": "/account/12345/msgs/abc",
}, "application/problem+json")
// => Content-Type: application/problem+json
// => "{
// => "type": "https://example.com/probs/out-of-credit",
// => "title": "You do not have enough credit.",
// => "status": 403,
// => "detail": "Your current balance is 30, but that costs 50.",
// => "instance": "/account/12345/msgs/abc",
// => }"
})

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 any, 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})
})

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.

tip

This is useful if you want to pass some specific data to the next middleware.

Signature
func (c Ctx) Locals(key any, value ...any) any
Example

// key is an unexported type for keys defined in this package.
// This prevents collisions with keys defined in other packages.
type key int

// userKey is the key for user.User values in Contexts. It is
// unexported; clients use user.NewContext and user.FromContext
// instead of using this key directly.
var userKey key

app.Use(func(c fiber.Ctx) error {
c.Locals(userKey, "admin")
return c.Next()
})

app.Get("/admin", func(c fiber.Ctx) error {
if c.Locals(userKey) == "admin" {
return c.Status(fiber.StatusOK).SendString("Welcome, admin!")
}
return c.SendStatus(fiber.StatusForbidden)

})

An alternative version of the Locals method that takes advantage of Go's generics feature is also available. This version allows for the manipulation and retrieval of local values within a request's context with a more specific data type.

Signature
func Locals[V any](c Ctx, key any, value ...V) V
Example
app.Use(func(c Ctx) error {
fiber.Locals[string](c, "john", "doe")
fiber.Locals[int](c, "age", 18)
fiber.Locals[bool](c, "isHuman", true)
return c.Next()
})
app.Get("/test", func(c Ctx) error {
fiber.Locals[string](c, "john") // "doe"
fiber.Locals[int](c, "age") // 18
fiber.Locals[bool](c, "isHuman") // true
return nil
})

Make sure to understand and correctly implement the Locals method in both its standard and generic form for better control over route-specific data within your application.

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 {
c.Location("http://example.com")

c.Location("/foo/bar")

return nil
})

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.

info

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...

In certain scenarios, it can be useful to have an alternative approach to handle different types of parameters, not just strings. This can be achieved using a generic Query function known as Params[V GenericType](c Ctx, key string, defaultValue ...V) V. This function is capable of parsing a query string and returning a value of a type that is assumed and specified by V GenericType.

Signature
func Params[v GenericType](c Ctx, key string, default value ...V) V
Example

// Get http://example.com/user/114
app.Get("/user/:id", func(c fiber.Ctx) error{
fiber.Params[string](c, "id") // returns "114" as string.
fiber.Params[int](c, "id") // returns 114 as integer
fiber.Params[string](c, "number") // retunrs "" (default string type)
fiber.Params[int](c, "number") // returns 0 (default integer value type)
})

The generic Params function supports returning the following data types based on V GenericType:

  • Integer: int, int8, int16, int32, int64
  • Unsigned integer: uint, uint8, uint16, uint32, uint64
  • Floating-point numbers: float32, float64
  • Boolean: bool
  • String: string
  • Byte array: []byte

ParamsParser​

This method is similar to BodyParser, but for path parameters. It is important to use the struct tag "params". For example, if you want to parse a path parameter with a field called Pass, you would use a struct field of params:"pass"

Signature
func (c Ctx) ParamsParser(out any) error
Example
// GET http://example.com/user/111
app.Get("/user/:id", func(c fiber.Ctx) error {
param := struct {ID uint `params:"id"`}{}

c.ParamsParser(&param) // "{"id": 111}"

// ...
})

Path​

Contains the path part of the request URL. Optionally, you could override the path by passing a string. For internal redirects, you might want to call RestartRouting instead of Next.

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"

// ...
})

Queries​

Queries is a function that returns an object containing a property for each query string parameter in the route.

Signature
func (c Ctx) Queries() map[string]string
Example
// GET http://example.com/?name=alex&want_pizza=false&id=

app.Get("/", func(c fiber.Ctx) error {
m := c.Queries()
m["name"] // "alex"
m["want_pizza"] // "false"
m["id"] // ""
// ...
})
Example
// GET http://example.com/?field1=value1&field1=value2&field2=value3

app.Get("/", func (c fiber.Ctx) error {
m := c.Queries()
m["field1"] // "value2"
m["field2"] // value3
})
Example
// GET http://example.com/?list_a=1&list_a=2&list_a=3&list_b[]=1&list_b[]=2&list_b[]=3&list_c=1,2,3

app.Get("/", func(c fiber.Ctx) error {
m := c.Queries()
m["list_a"] // "3"
m["list_b[]"] // "3"
m["list_c"] // "1,2,3"
})
Example
// GET /api/posts?filters.author.name=John&filters.category.name=Technology

app.Get("/", func(c fiber.Ctx) error {
m := c.Queries()
m["filters.author.name"] // John
m["filters.category.name"] // Technology
})
Example
// GET /api/posts?tags=apple,orange,banana&filters[tags]=apple,orange,banana&filters[category][name]=fruits&filters.tags=apple,orange,banana&filters.category.name=fruits

app.Get("/", func(c fiber.Ctx) error {
m := c.Queries()
m["tags"] // apple,orange,banana
m["filters[tags]"] // apple,orange,banana
m["filters[category][name]"] // fruits
m["filters.tags"] // apple,orange,banana
m["filters.category.name"] // fruits
})

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.

info

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/?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...

In certain scenarios, it can be useful to have an alternative approach to handle different types of query parameters, not just strings. This can be achieved using a generic Query function known as Query[V GenericType](c Ctx, key string, defaultValue ...V) V. This function is capable of parsing a query string and returning a value of a type that is assumed and specified by V GenericType.

Here is the signature for the generic Query function:

Signature
func Query[V GenericType](c Ctx, key string, defaultValue ...V) V

Consider this example:

Example
// GET http://example.com/?page=1&brand=nike&new=true

app.Get("/", func(c fiber.Ctx) error {
fiber.Query[int](c, "page") // 1
fiber.Query[string](c, "brand") // "nike"
fiber.Query[bool](c, "new") // true

// ...
})

In this case, Query[V GenericType](c Ctx, key string, defaultValue ...V) V can retrieve 'page' as an integer, 'brand' as a string, and 'new' as a boolean. The function uses the appropriate parsing function for each specified type to ensure the correct type is returned. This simplifies the retrieval process of different types of query parameters, making your controller actions cleaner.

The generic Query function supports returning the following data types based on V GenericType:

  • Integer: int, int8, int16, int32, int64
  • Unsigned integer: uint, uint8, uint16, uint32, uint64
  • Floating-point numbers: float32, float64
  • Boolean: bool
  • String: string
  • Byte array: []byte

QueryParser​

This method is similar to BodyParser, but for query parameters. It is important to use the struct tag "query". For example, if you want to parse a query parameter with a field called Pass, you would use a struct field of query:"pass".

Signature
func (c Ctx) QueryParser(out any) 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
// fiber.Config{EnableSplittingOnParsers: false} - default
log.Println(p.Products) // ["shoe,hat"]
// fiber.Config{EnableSplittingOnParsers: true}
// log.Println(p.Products) // ["shoe", "hat"]


// ...
})
// Run tests with the following curl command

// curl "http://localhost:3000/?name=john&pass=doe&products=shoe,hat"
info

For more parser settings please look here Config

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.

info

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)
})

RedirectToRoute​

Redirects to the specific route along with the parameters and with specified status, a positive integer that corresponds to an HTTP status code.

info

If not specified, status defaults to 302 Found.

info

If you want to send queries to route, you must add "queries" key typed as map[string]string to params.

Signature
func (c Ctx) RedirectToRoute(routeName string, params fiber.Map, status ...int) error
Example
app.Get("/", func(c fiber.Ctx) error {
// /user/fiber
return c.RedirectToRoute("user", fiber.Map{
"name": "fiber"
})
})

app.Get("/with-queries", func(c fiber.Ctx) error {
// /user/fiber?data[0][name]=john&data[0][age]=10&test=doe
return c.RedirectToRoute("user", fiber.Map{
"name": "fiber",
"queries": map[string]string{"data[0][name]": "john", "data[0][age]": "10", "test": "doe"},
})
})

app.Get("/user/:name", func(c fiber.Ctx) error {
return c.SendString(c.Params("name"))
}).Name("user")

RedirectBack​

Redirects back to refer URL. It redirects to fallback URL if refer header doesn't exists, with specified status, a positive integer that corresponds to an HTTP status code.

info

If not specified, status defaults to 302 Found.

Signature
func (c Ctx) RedirectBack(fallback string, status ...int) error
Example
app.Get("/", func(c fiber.Ctx) error {
return c.SendString("Home page")
})
app.Get("/test", func(c fiber.Ctx) error {
c.Set("Content-Type", "text/html")
return c.SendString(`<a href="/back">Back</a>`)
})

app.Get("/back", func(c fiber.Ctx) error {
return c.RedirectBack("/")
})

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 any, layouts ...string) error

Request​

Request return the *fasthttp.Request pointer

Signature
func (c Ctx) Request() *fasthttp.Request
Example
app.Get("/", func(c fiber.Ctx) error {
c.Request().Header.Method()
// => []byte("GET")
})

ReqHeaderParser​

This method is similar to BodyParser, but for request headers. It is important to use the struct tag "reqHeader". For example, if you want to parse a request header with a field called Pass, you would use a struct field of reqHeader:"pass".

Signature
func (c Ctx) ReqHeaderParser(out any) error
Example
// Field names should start with an uppercase letter
type Person struct {
Name string `reqHeader:"name"`
Pass string `reqHeader:"pass"`
Products []string `reqHeader:"products"`
}

app.Get("/", func(c fiber.Ctx) error {
p := new(Person)

if err := c.ReqHeaderParser(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/" -H "name: john" -H "pass: doe" -H "products: shoe,hat"

Response​

Response return the *fasthttp.Response pointer

Signature
func (c Ctx) Response() *fasthttp.Response
Example
app.Get("/", func(c fiber.Ctx) error {
c.Response().BodyWriter().Write([]byte("Hello, World!"))
// => "Hello, World!"
return nil
})

RestartRouting​

Instead of executing the next method when calling Next, RestartRouting restarts execution from the first method that matches the current route. This may be helpful after overriding the path, i. e. an internal redirect. Note that handlers might be executed again which could result in an infinite loop.

Signature
func (c Ctx) RestartRouting() error
Example
app.Get("/new", func(c fiber.Ctx) error {
return c.SendString("From /new")
})

app.Get("/old", func(c fiber.Ctx) error {
c.Path("/new")
return c.RestartRouting()
})

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]

// ...
})
caution

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
}
})

SaveFileToStorage​

Method is used to save any multipart file to an external storage system.

Signature
func (c Ctx) SaveFileToStorage(fileheader *multipart.FileHeader, path string, storage Storage) error
Example
storage := memory.New()

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 storage:
if err := c.SaveFileToStorage(file, fmt.Sprintf("./%s", file.Filename), storage); 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.

tip

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.

caution

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);
})
info

If the file contains an url specific character you have to escape it before passing the file path into the sendFile function.

Example
app.Get("/file-with-url-chars", func(c fiber.Ctx) error {
return c.SendFile(url.PathEscape("hash_sign_#.txt"))
})
info

For sending files from embedded file system this functionality can be used

SendStatus​

Sets the status code and the correct status message in the body, if the response body is empty.

tip

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"

// ...
})

SetParserDecoder​

Allow you to config BodyParser/QueryParser decoder, base on schema's options, providing possibility to add custom type for parsing.

Signature
func SetParserDecoder(parserConfig fiber.ParserConfig{
IgnoreUnknownKeys bool,
ParserType []fiber.ParserType{
Customtype any,
Converter func(string) reflect.Value,
},
ZeroEmpty bool,
SetAliasTag string,
})
Example

type CustomTime time.Time

// String() returns the time in string
func (ct *CustomTime) String() string {
t := time.Time(*ct).String()
return t
}

// Register the converter for CustomTime type format as 2006-01-02
var timeConverter = func(value string) reflect.Value {
fmt.Println("timeConverter", value)
if v, err := time.Parse("2006-01-02", value); err == nil {
return reflect.ValueOf(v)
}
return reflect.Value{}
}

customTime := fiber.ParserType{
Customtype: CustomTime{},
Converter: timeConverter,
}

// Add setting to the Decoder
fiber.SetParserDecoder(fiber.ParserConfig{
IgnoreUnknownKeys: true,
ParserType: []fiber.ParserType{customTime},
ZeroEmpty: true,
})

// Example to use CustomType, you pause custom time format not in RFC3339
type Demo struct {
Date CustomTime `form:"date" query:"date"`
Title string `form:"title" query:"title"`
Body string `form:"body" query:"body"`
}

app.Post("/body", func(c fiber.Ctx) error {
var d Demo
c.BodyParser(&d)
fmt.Println("d.Date", d.Date.String())
return c.JSON(d)
})

app.Get("/query", func(c fiber.Ctx) error {
var d Demo
c.QueryParser(&d)
fmt.Println("d.Date", d.Date.String())
return c.JSON(d)
})

// curl -X POST -F title=title -F body=body -F date=2021-10-20 http://localhost:3000/body

// curl -X GET "http://localhost:3000/query?title=title&body=body&date=2021-10-20"

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.

info

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.

info

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!"
})

Writef​

Writef adopts the string with variables

Signature
func (c Ctx) Writef(f string, a ...any) (n int, err error)
Example
app.Get("/", func(c fiber.Ctx) error {
world := "World!"
c.Writef("Hello, %s", world) // => "Hello, World!"

fmt.Fprintf(c, "%s\n", "Hello, World!") // "Hello, World!Hello, World!"
})

WriteString​

WriteString adopts the string

Signature
func (c Ctx) WriteString(s string) (n int, err error)
Example
app.Get("/", func(c fiber.Ctx) error {
c.WriteString("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

// ...
})

XML​

Converts any interface or string to XML using the standard encoding/xml package.

info

XML also sets the content header to application/xml.

Signature
func (c Ctx) XML(data any) error
Example
type SomeStruct struct {
XMLName xml.Name `xml:"Fiber"`
Name string `xml:"Name"`
Age uint8 `xml:"Age"`
}

app.Get("/", func(c fiber.Ctx) error {
// Create data struct:
data := SomeStruct{
Name: "Grame",
Age: 20,
}

return c.XML(data)
// <Fiber>
// <Name>Grame</Name>
// <Age>20</Age>
// </Fiber>
})

Convert​

Converts a string value to a specified type, handling errors and optional default values. This function simplifies the conversion process by encapsulating error handling and the management of default values, making your code cleaner and more consistent.

Signature
func Convert[T any](value string, convertor func(string) (T, error), defaultValue ...T) (*T, error)
Example
// GET http://example.com/id/bb70ab33-d455-4a03-8d78-d3c1dacae9ff
app.Get("/id/:id", func(c fiber.Ctx) error {
fiber.Convert(c.Params("id"), uuid.Parse) // UUID(bb70ab33-d455-4a03-8d78-d3c1dacae9ff), nil


// GET http://example.com/search?id=65f6f54221fb90e6a6b76db7
app.Get("/search", func(c fiber.Ctx) error) {
fiber.Convert(c.Query("id"), mongo.ParseObjectID) // objectid(65f6f54221fb90e6a6b76db7), nil
fiber.Convert(c.Query("id"), uuid.Parse) // uuid.Nil, error(cannot parse given uuid)
fiber.Convert(c.Query("id"), uuid.Parse, mongo.NewObjectID) // new object id generated and return nil as error.
}

// ...
})