id	title	description	sidebar_position
app	🚀 App	The app instance conventionally denotes the Fiber application.	2

import Reference from '@site/src/components/reference';

Routing

import RoutingHandler from './../partials/routing/handler.md';

Static

Use the Static method to serve static files such as images, CSS, and JavaScript.

:::info By default, Static will serve index.html files in response to a request on a directory. :::

func (app *App) Static(prefix, root string, config ...Static) Router

Use the following code to serve files in a directory named ./public

// Serve files from multiple directories
app.Static("/", "./public")

// => http://localhost:3000/hello.html
// => http://localhost:3000/js/jquery.js
// => http://localhost:3000/css/style.css

// Serve files from "./files" directory:
app.Static("/", "./files")

You can use any virtual path prefix (where the path does not actually exist in the file system) for files that are served by the Static method, specify a prefix path for the static directory, as shown below:

app.Static("/static", "./public")

// => http://localhost:3000/static/hello.html
// => http://localhost:3000/static/js/jquery.js
// => http://localhost:3000/static/css/style.css

Config

If you want to have a little bit more control regarding the settings for serving static files. You could use the fiber.Static struct to enable specific settings.

Property	Type	Description	Default
Compress	`bool`	When set to true, the server tries minimizing CPU usage by caching compressed files. This works differently than the compress middleware.	false
ByteRange	`bool`	When set to true, enables byte range requests.	false
Browse	`bool`	When set to true, enables directory browsing.	false
Download	`bool`	When set to true, enables direct download.	false
Index	`string`	The name of the index file for serving a directory.	"index.html"
CacheDuration	`time.Duration`	Expiration duration for inactive file handlers. Use a negative `time.Duration` to disable it.	10 * time.Second
MaxAge	`int`	The value for the `Cache-Control` HTTP-header that is set on the file response. MaxAge is defined in seconds.	0
ModifyResponse	`Handler`	ModifyResponse defines a function that allows you to alter the response.	nil
Next	`func(c Ctx) bool`	Next defines a function to skip this middleware when returned true.	nil

// Custom config
app.Static("/", "./public", fiber.Static{
  Compress:      true,
  ByteRange:     true,
  Browse:        true,
  Index:         "john.html",
  CacheDuration: 10 * time.Second,
  MaxAge:        3600,
})

Route Handlers

Mounting

You can Mount Fiber instance using the app.Use method similar to express.

func main() {
    app := fiber.New()
    micro := fiber.New()
    app.Use("/john", micro) // GET /john/doe -> 200 OK

    micro.Get("/doe", func(c fiber.Ctx) error {
        return c.SendStatus(fiber.StatusOK)
    })

    log.Fatal(app.Listen(":3000"))
}

MountPath

The MountPath property contains one or more path patterns on which a sub-app was mounted.

func (app *App) MountPath() string

func main() {
	app := fiber.New()
	one := fiber.New()
	two := fiber.New()
	three := fiber.New()

	two.Use("/three", three)
	one.Use("/two", two)
	app.Use("/one", one)
  
	one.MountPath()   // "/one"
	two.MountPath()   // "/one/two"
	three.MountPath() // "/one/two/three"
	app.MountPath()   // ""
}

:::caution Mounting order is important for MountPath. If you want to get mount paths properly, you should start mounting from the deepest app. :::

Group

You can group routes by creating a *Group struct.

func (app *App) Group(prefix string, handlers ...Handler) Router

func main() {
  app := fiber.New()

  api := app.Group("/api", handler)  // /api

  v1 := api.Group("/v1", handler)   // /api/v1
  v1.Get("/list", handler)          // /api/v1/list
  v1.Get("/user", handler)          // /api/v1/user

  v2 := api.Group("/v2", handler)   // /api/v2
  v2.Get("/list", handler)          // /api/v2/list
  v2.Get("/user", handler)          // /api/v2/user

  log.Fatal(app.Listen(":3000"))
}

Route

Returns an instance of a single route, which you can then use to handle HTTP verbs with optional middleware.

Similar to express.

func (app *App) Route(path string) Register

Click here to see the `Register` interface

type Register interface {
  All(handler Handler, middleware ...Handler) Register
  Get(handler Handler, middleware ...Handler) Register
  Head(handler Handler, middleware ...Handler) Register
  Post(handler Handler, middleware ...Handler) Register
  Put(handler Handler, middleware ...Handler) Register
  Delete(handler Handler, middleware ...Handler) Register
  Connect(handler Handler, middleware ...Handler) Register
  Options(handler Handler, middleware ...Handler) Register
  Trace(handler Handler, middleware ...Handler) Register
  Patch(handler Handler, middleware ...Handler) Register

  Add(methods []string, handler Handler, middleware ...Handler) Register

  Static(root string, config ...Static) Register

  Route(path string) Register
}

func main() {
  app := fiber.New()

  // use `Route` as chainable route declaration method
  app.Route("/test").Get(func(c fiber.Ctx) error {
    return c.SendString("GET /test")
  })
  
  app.Route("/events").all(func(c fiber.Ctx) error {
    // runs for all HTTP verbs first
    // think of it as route specific middleware!
  })
  .get(func(c fiber.Ctx) error {
    return c.SendString("GET /events")
  })
  .post(func(c fiber.Ctx) error {
    // maybe add a new event...
  })
  
  // combine multiple routes
  app.Route("/v2").Route("/user").Get(func(c fiber.Ctx) error {
    return c.SendString("GET /v2/user")
  })
  
  // use multiple methods
  app.Route("/api").Get(func(c fiber.Ctx) error {
    return c.SendString("GET /api")
  }).Post(func(c fiber.Ctx) error {
    return c.SendString("POST /api")
  })

  log.Fatal(app.Listen(":3000"))
}

HandlersCount

This method returns the amount of registered handlers.

func (app *App) HandlersCount() uint32

Stack

This method returns the original router stack

func (app *App) Stack() [][]*Route

var handler = func(c fiber.Ctx) error { return nil }

func main() {
    app := fiber.New()

    app.Get("/john/:age", handler)
    app.Post("/register", handler)

    data, _ := json.MarshalIndent(app.Stack(), "", "  ")
    fmt.Println(string(data))

    app.Listen(":3000")
}

Click here to see the result

[
  [
    {
      "method": "GET",
      "path": "/john/:age",
      "params": [
        "age"
      ]
    }
  ],
  [
    {
      "method": "HEAD",
      "path": "/john/:age",
      "params": [
        "age"
      ]
    }
  ],
  [
    {
      "method": "POST",
      "path": "/register",
      "params": null
    }
  ]
]

Name

This method assigns the name of latest created route.

func (app *App) Name(name string) Router

var handler = func(c fiber.Ctx) error { return nil }

func main() {
    app := fiber.New()

    app.Get("/", handler)
    app.Name("index")

    app.Get("/doe", handler).Name("home")

    app.Trace("/tracer", handler).Name("tracert")

    app.Delete("/delete", handler).Name("delete")

    a := app.Group("/a")
    a.Name("fd.")

    a.Get("/test", handler).Name("test")

    data, _ := json.MarshalIndent(app.Stack(), "", "  ")
    fmt.Print(string(data))

    app.Listen(":3000")

}

Click here to see the result

[
  [
    {
      "method": "GET",
      "name": "index",
      "path": "/",
      "params": null
    },
    {
      "method": "GET",
      "name": "home",
      "path": "/doe",
      "params": null
    },
    {
      "method": "GET",
      "name": "fd.test",
      "path": "/a/test",
      "params": null
    }
  ],
  [
    {
      "method": "HEAD",
      "name": "",
      "path": "/",
      "params": null
    },
    {
      "method": "HEAD",
      "name": "",
      "path": "/doe",
      "params": null
    },
    {
      "method": "HEAD",
      "name": "",
      "path": "/a/test",
      "params": null
    }
  ],
  null,
  null,
  [
    {
      "method": "DELETE",
      "name": "delete",
      "path": "/delete",
      "params": null
    }
  ],
  null,
  null,
  [
    {
      "method": "TRACE",
      "name": "tracert",
      "path": "/tracer",
      "params": null
    }
  ],
  null
]

GetRoute

This method gets the route by name.

func (app *App) GetRoute(name string) Route

var handler = func(c fiber.Ctx) error { return nil }

func main() {
    app := fiber.New()

    app.Get("/", handler).Name("index")
    
    data, _ := json.MarshalIndent(app.GetRoute("index"), "", "  ")
	fmt.Print(string(data))


	app.Listen(":3000")
}

Click here to see the result

{
  "method": "GET",
  "name": "index",
  "path": "/",
  "params": null
}

GetRoutes

This method gets all routes.

func (app *App) GetRoutes(filterUseOption ...bool) []Route

When filterUseOption equal to true, it will filter the routes registered by the middleware.

func main() {
	app := fiber.New()
	app.Post("/", func (c fiber.Ctx) error {
		return c.SendString("Hello, World!")
	}).Name("index")
	data, _ := json.MarshalIndent(app.GetRoutes(true), "", "  ")
	fmt.Print(string(data))
}

Click here to see the result

[
    {
        "method": "POST",
        "name": "index",
        "path": "/",
        "params": null
    }
]

Config

Config returns the app config as value ( read-only ).

func (app *App) Config() Config

Handler

Handler returns the server handler that can be used to serve custom \*fasthttp.RequestCtx requests.

func (app *App) Handler() fasthttp.RequestHandler

ErrorHandler

Errorhandler executes the process which was defined for the application in case of errors, this is used in some cases in middlewares.

func (app *App) ErrorHandler(ctx Ctx, err error) error

NewCtxFunc

NewCtxFunc allows to customize the ctx struct as we want.

func (app *App) NewCtxFunc(function func(app *App) CustomCtx)

type CustomCtx struct {
	DefaultCtx
}

// Custom method
func (c *CustomCtx) Params(key string, defaultValue ...string) string {
	return "prefix_" + c.DefaultCtx.Params(key)
}

app := New()
app.NewCtxFunc(func(app *fiber.App) fiber.CustomCtx {
    return &CustomCtx{
        DefaultCtx: *NewDefaultCtx(app),
    }
})
// curl http://localhost:3000/123
app.Get("/:id", func(c Ctx) error {
    // use custom method - output: prefix_123
    return c.SendString(c.Params("id"))
})

RegisterCustomBinder

You can register custom binders to use as Bind().Custom("name"). They should be compatible with CustomBinder interface.

func (app *App) RegisterCustomBinder(binder CustomBinder)

app := fiber.New()

// My custom binder
customBinder := &customBinder{}
// Name of custom binder, which will be used as Bind().Custom("name")
func (*customBinder) Name() string {
    return "custom"
}
// Is used in the Body Bind method to check if the binder should be used for custom mime types
func (*customBinder) MIMETypes() []string {
    return []string{"application/yaml"}
}
// Parse the body and bind it to the out interface
func (*customBinder) Parse(c Ctx, out any) error {
    // parse yaml body
    return yaml.Unmarshal(c.Body(), out)
}
// Register custom binder
app.RegisterCustomBinder(customBinder)

// curl -X POST http://localhost:3000/custom -H "Content-Type: application/yaml" -d "name: John"
app.Post("/custom", func(c Ctx) error {
    var user User
    // output: {Name:John}
    // Custom binder is used by the name
    if err := c.Bind().Custom("custom", &user); err != nil {
        return err
    }
    // ...
    return c.JSON(user)
})
// curl -X POST http://localhost:3000/normal -H "Content-Type: application/yaml" -d "name: Doe"
app.Post("/normal", func(c Ctx) error {
    var user User
    // output: {Name:Doe}
    // Custom binder is used by the mime type
    if err := c.Bind().Body(&user); err != nil {
        return err
    }
    // ...
    return c.JSON(user)
})

RegisterCustomConstraint

RegisterCustomConstraint allows to register custom constraint.

func (app *App) RegisterCustomConstraint(constraint CustomConstraint)

See Custom Constraint section for more information.

SetTLSHandler

Use SetTLSHandler to set ClientHelloInfo when using TLS with Listener.

func (app *App) SetTLSHandler(tlsHandler *TLSHandler)

Test

Testing your application is done with the Test method. Use this method for creating _test.go files or when you need to debug your routing logic. The default timeout is 1s if you want to disable a timeout altogether, pass -1 as a second argument.

func (app *App) Test(req *http.Request, msTimeout ...int) (*http.Response, error)

// Create route with GET method for test:
app.Get("/", func(c fiber.Ctx) error {
  fmt.Println(c.BaseURL())              // => http://google.com
  fmt.Println(c.Get("X-Custom-Header")) // => hi

  return c.SendString("hello, World!")
})

// http.Request
req := httptest.NewRequest("GET", "http://google.com", nil)
req.Header.Set("X-Custom-Header", "hi")

// http.Response
resp, _ := app.Test(req)

// Do something with results:
if resp.StatusCode == fiber.StatusOK {
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body)) // => Hello, World!
}

Hooks

Hooks is a method to return hooks property.

func (app *App) Hooks() *Hooks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

app.md

app.md

Routing

Static

Config

Route Handlers

Mounting

MountPath

Group

Route

HandlersCount

Stack

Name

GetRoute

GetRoutes

Config

Handler

ErrorHandler

NewCtxFunc

RegisterCustomBinder

RegisterCustomConstraint

SetTLSHandler

Test

Hooks

Files

app.md

Latest commit

History

app.md

File metadata and controls

Routing

Static

Config

Route Handlers

Mounting

MountPath

Group

Route

HandlersCount

Stack

Name

GetRoute

GetRoutes

Config

Handler

ErrorHandler

NewCtxFunc

RegisterCustomBinder

RegisterCustomConstraint

SetTLSHandler

Test

Hooks