An Express-inspired web framework
written in Go.

Fiber is a Go web framework built on top of Fasthttp, the fastest HTTP engine for Go. It's designed to ease development with performance in mind.

package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

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

    app.Get("/", func (c fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })

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

→

http://localhost:3000

Hello, World!

Get Started →✨ Ask AI Read FAQ

Fiber in Action

How Fiber applications are built: pick a topic, read the code.

Routes are declared Express-style with a method, a path, and a handler. Dynamic segments like :name are captured and read through c.Params, and wildcards like * match everything below a prefix. Routing guide →

app.Get("/", func(c fiber.Ctx) error {
    return c.SendString("Hello, World!")
})

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

app.Get("/files/*", func(c fiber.Ctx) error {
    return c.SendString("Path: " + c.Params("*"))
})

app.Use chains middleware into the request cycle. Here logger.New() prints every request and limiter.New() throttles abusive clients. Middleware runs in the order you register it, so requests flow through the chain top to bottom. Middleware overview →

import (
    "github.com/gofiber/fiber/v3/middleware/limiter"
    "github.com/gofiber/fiber/v3/middleware/logger"
)

// Log every request
app.Use(logger.New())

// 20 requests per 30 seconds per client
app.Use(limiter.New(limiter.Config{
    Max:        20,
    Expiration: 30 * time.Second,
}))

c.JSON serializes structs or a fiber.Map straight into the response body, and status codes chain through c.Status. Reading request data works the same way in reverse with c.Bind. Context API →

app.Get("/api/posts", func(c fiber.Ctx) error {
    posts := getPosts() // your logic
    if len(posts) == 0 {
        return c.Status(404).JSON(&fiber.Map{
            "success": false,
            "error":   "There are no posts!",
        })
    }
    return c.JSON(&fiber.Map{
        "success": true,
        "posts":   posts,
    })
})

static.New serves HTML, CSS, JavaScript, and images from one or more directories on the same route, with options like compression, caching, and directory browsing. Static middleware →

import "github.com/gofiber/fiber/v3/middleware/static"

app.Get("/*", static.New("./public"))

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

Set a Views engine and c.Render fills your templates server-side. Engines are swappable behind the same interface, so your handlers never change. Template engines →

import "github.com/gofiber/template/html/v3"

app := fiber.New(fiber.Config{
    Views: html.New("./views", ".html"),
})

app.Get("/", func(c fiber.Ctx) error {
    return c.Render("index", fiber.Map{
        "Title": "Hello, World!",
    })
})

Extreme Performance

Since Fiber is built on top of Fasthttp, your apps will enjoy unmatching performance! Don't believe us? Here's a benchmark that proves how Fiber shines compared to other frameworks:

The framework

Built into the Core

Everyday capabilities that ship with the framework itself. No extra packages, nothing else to install.

Request BindingParse JSON bodies, forms, query strings, and headers into Go structs with c.Bind.Route ConstraintsValidate parameters in the route pattern itself: :id<int> never matches "abc".Error HandlingReturn errors from handlers and shape every response in one central ErrorHandler.HTTP ClientCall other services with the built-in, Fasthttp-powered client.TestingTest handlers in-process with app.Test, no port and no running server needed.Hooks & ServicesReact to lifecycle events, and let Fiber start and stop your backing services.State ManagementShare typed application state across handlers without global variables.Graceful ShutdownFinish in-flight requests and run cleanup hooks before the process exits.Type-Safe HelpersRead params, query values, and locals as real Go types with generic helpers.

Ready to ship something fast?

Start with one file, add middleware as you grow, and deploy a single binary.

Get Started →Browse Recipes

Beyond the core

The Official Ecosystem

Complete catalogs of official building blocks: middleware, storage drivers, template engines, and contrib integrations, all maintained by the Fiber team.