Fiber

https://docs.gofiber.io/next
Admin
Fiber is an Express-inspired web framework built on Fasthttp that enables rapid development of...
Tokens:198,309
Snippets:2,113
Trust Score:8.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Basic Route Handler Examples

Source: https://docs.gofiber.io/next/api/app

Simple examples of registering GET and POST handlers.

```go
// Simple GET handler  

app.Get("/api/list", func(c fiber.Ctx) error {  

    return c.SendString("I'm a GET request!")  

})  

  

// Simple POST handler  

app.Post("/api/register", func(c fiber.Ctx) error {  

    return c.SendString("I'm a POST request!")  

})
```

--------------------------------

### Example Usage of Base URL

Source: https://docs.gofiber.io/next/client/rest

Demonstrates initializing a client, setting a base URL, and performing a GET request.

```go
cc := client.New()  

cc.SetBaseURL("https://httpbin.org/")  

  

resp, err := cc.Get("/get")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))
```

--------------------------------

### Basic Listen Usage

Source: https://docs.gofiber.io/next/api/fiber

Examples of starting a Fiber server with default settings, prefork enabled, or a specific host address.

```go
// Listen on port :8080  

app.Listen(":8080")  

  

// Listen on port :8080 with Prefork  

app.Listen(":8080", fiber.ListenConfig{EnablePrefork: true})  

  

// Custom host  

app.Listen("127.0.0.1:8080")  
```

--------------------------------

### Use Middleware Usage Examples

Source: https://docs.gofiber.io/next/api/app

Examples demonstrating how to use the Use method for global middleware, prefix-based middleware, and sub-app mounting.

```go
// Match any request  

app.Use(func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match request starting with /api  

app.Use("/api", func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match requests starting with /api or /home (multiple-prefix support)  

app.Use([]string{"/api", "/home"}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Attach multiple handlers (they run in order; each must call c.Next() to continue)  

app.Use("/api", func(c fiber.Ctx) error {  

    c.Set("X-Custom-Header", "value")  

    return c.Next()  

}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Mount a sub-app  

app.Use("/api", api)
```

--------------------------------

### Configuring BasicAuth Middleware

Source: https://docs.gofiber.io/next/middleware/basicauth

Examples of initializing the middleware with minimal configuration or a fully customized setup including a custom authorizer and unauthorized handler.

```go
// Provide a minimal config  
app.Use(basicauth.New(basicauth.Config{  

    Users: map[string]string{  

        // "doe" hashed using SHA-256  

        "john":  "{SHA256}eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=",  

        // "123456" hashed using bcrypt  

        "admin": "$2a$10$gTYwCN66/tBRoCr3.TXa1.v1iyvwIF7GRBqxzv7G.AHLMt/owXrp.",  

    },  

}))  

  

// Or extend your config for customization  
app.Use(basicauth.New(basicauth.Config{  

    Users: map[string]string{  

        // "doe" hashed using SHA-256  

        "john":  "{SHA256}eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=",  

        // "123456" hashed using bcrypt  

        "admin": "$2a$10$gTYwCN66/tBRoCr3.TXa1.v1iyvwIF7GRBqxzv7G.AHLMt/owXrp.",  

    },  

    Realm: "Forbidden",  

    Authorizer: func(user, pass string, c fiber.Ctx) bool {  

        // custom validation logic  

        return (user == "john" || user == "admin")  

    },  

    Unauthorized: func(c fiber.Ctx) error {  

        return c.SendFile("./unauthorized.html")  

    },  

}))  
```

--------------------------------

### Serving a single file

Source: https://docs.gofiber.io/next/middleware/static

This example demonstrates serving a single file ('./public/hello.html') for all routes starting with '/static'.

```APIDOC
## Use /static

### Description
Serves the './public/hello.html' file for routes starting with '/static'.

### Method
Use

### Endpoint
/static

### Request Example
```go
app.Use("/static", static.New("./public/hello.html"))
```

### Test
```bash
curl http://localhost:3000/static # will show hello.html
curl http://localhost:3000/static/john/doe # will show hello.html
```
```

--------------------------------

### Serving files from a directory with Use

Source: https://docs.gofiber.io/next/middleware/static

This example shows how to use the `Use` method to serve static files from the './public' directory for all routes starting with '/'.

```APIDOC
## Use /

### Description
Serves static files from the './public' directory for all routes.

### Method
Use

### Endpoint
/

### Request Example
```go
app.Use("/", static.New("./public"))
```

### Test
```bash
curl http://localhost:3000/hello.html
curl http://localhost:3000/css/style.css
```
```

--------------------------------

### Install MsgPack Libraries

Source: https://docs.gofiber.io/next/guide/advance-format

Commands to install popular MsgPack libraries for Go.

```bash
go get github.com/vmihailenco/msgpack  

# or  

go get github.com/shamaton/msgpack/v3
```

--------------------------------

### Using Pprof Middleware

Source: https://docs.gofiber.io/next/middleware/pprof

Examples of initializing the middleware with default settings or a custom URL prefix.

```go
// Initialize default config  

app.Use(pprof.New())

  

// Or customize the config  

  

// For multi-ingress systems, add a URL prefix:  

app.Use(pprof.New(pprof.Config{Prefix: "/endpoint-prefix"}))  

  

// The resulting URL is "/endpoint-prefix/debug/pprof/"
```

--------------------------------

### Configuring RequestID Middleware

Source: https://docs.gofiber.io/next/middleware/requestid

Examples for initializing the middleware with default settings or a custom configuration.

```go
// Initialize default config  

app.Use(requestid.New())  

  

// Or extend your config for customization  

app.Use(requestid.New(requestid.Config{  

    Header:    "X-Custom-Header",  

    Generator: func() string {  

        return "static-id"  

    },  

}))  
```

--------------------------------

### View service startup logs

Source: https://docs.gofiber.io/next/whats_new

Example output showing registered services during application startup.

```text
$ go run . -v  
  
    _______ __  

   / ____(_) /_  ___  _____  

  / /_  / / __ \/ _ \/ ___/  

 / __/ / / /_/ /  __/ /  

/_/   /_/_.___/\___/_/          v3.0.0  

--------------------------------------------------  

INFO Server started on:         http://127.0.0.1:3000 (bound on host 0.0.0.0 and port 3000)  

INFO Services:     2  

INFO   🧩 [ RUNNING ] postgres:latest  

INFO   🧩 [ RUNNING ] redis:latest  

INFO Total handlers count:      2  

INFO Prefork:                   Disabled  

INFO PID:                       12279  

INFO Total process count:       1
```

--------------------------------

### Install validator package

Source: https://docs.gofiber.io/next/guide/validation

Install the go-playground/validator package to use as the validation engine.

```bash
go get github.com/go-playground/validator/v10
```

--------------------------------

### Redirect Middleware Implementation

Source: https://docs.gofiber.io/next/middleware/redirect

Example showing how to configure and use the redirect middleware with path rules.

```go
package main  
  
import (  
    "github.com/gofiber/fiber/v3"  
    "github.com/gofiber/fiber/v3/middleware/redirect"  
)  
  
func main() {  
    app := fiber.New()  
  
    app.Use(redirect.New(redirect.Config{  
      Rules: map[string]string{  
        "/old":   "/new",  
        "/old/*": "/new/$1",  
      },  
      StatusCode: fiber.StatusMovedPermanently,  
    }))  
  
    app.Get("/new", func(c fiber.Ctx) error {  
      return c.SendString("Hello, World!")  
    })  
    app.Get("/new/*", func(c fiber.Ctx) error {  
      return c.SendString("Wildcard: " + c.Params("*"))  
    })  
  
    app.Listen(":3000")  
}  
```

--------------------------------

### SetCookies Usage Example

Source: https://docs.gofiber.io/next/client/request

Demonstrates setting cookies and performing a request.

```go
req := client.AcquireRequest()  

defer client.ReleaseRequest(req)  

  

req.SetCookies(map[string]string{  

    "cookie1": "value1",  

    "cookie2": "value2",  

})  

  

resp, err := req.Get("https://httpbin.org/cookies")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))
```

```json
{
  "cookies": {
    "test": "123"
  }
}
```

--------------------------------

### Install CBOR Library

Source: https://docs.gofiber.io/next/guide/advance-format

Command to install the fxamacker/cbor library.

```bash
go get github.com/fxamacker/cbor/v2
```

--------------------------------

### Initializing the Middleware

Source: https://docs.gofiber.io/next/middleware/earlydata

Examples of applying the middleware to a Fiber application using default or custom configurations.

```go
// Initialize default config  

app.Use(earlydata.New())  

  

// Or extend your config for customization  

app.Use(earlydata.New(earlydata.Config{  

    Error: fiber.ErrTooEarly,  

    // ...  

}))  
```

--------------------------------

### Basic Timeout Example

Source: https://docs.gofiber.io/next/middleware/timeout

This example demonstrates how to use the timeout middleware to set a 2-second timeout for requests. The handler simulates work using sleepWithContext, which respects context cancellation.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "time"

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

func sleepWithContext(ctx context.Context, d time.Duration) error {
    select {
    case <-time.After(d):
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

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

    handler := func(c fiber.Ctx) error {
        delay, _ := time.ParseDuration(c.Params("delay") + "ms")
        if err := sleepWithContext(c.Context(), delay); err != nil {
            return fmt.Errorf("%w: execution error", err)
        }

        return c.SendString("finished")
    }

    app.Get("/sleep/:delay", timeout.New(handler, timeout.Config{
        Timeout: 2 * time.Second,
    }))

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

--------------------------------

### Configure and Use ETag Middleware

Source: https://docs.gofiber.io/next/middleware/etag

Examples of applying the middleware with default and custom configurations.

```go
// Initialize default config  

app.Use(etag.New())

  

// GET / -> ETag: "13-1831710635"  

app.Get("/", func(c fiber.Ctx) error {  

    return c.SendString("Hello, World!")  

})

  

// Or extend your config for customization  

app.Use(etag.New(etag.Config{  

    Weak: true,  

}))

  

// GET / -> ETag: W/"13-1831710635"  

app.Get("/", func(c fiber.Ctx) error {  

    return c.SendString("Hello, World!")  

})
```

--------------------------------

### Configuring Recover Middleware

Source: https://docs.gofiber.io/next/middleware/recover

Examples of default configuration and custom PanicHandler implementations.

```go
var ConfigDefault = recoverer.Config{  

    Next:              nil,  

    PanicHandler:      DefaultPanicHandler,  

    StackTraceHandler: defaultStackTraceHandler,  

    EnableStackTrace:  false,  

}  

  

// Set up a PanicHandler to hide internals.  

app.Use(recoverer.New(recoverer.Config{PanicHandler: func(c fiber.Ctx, r any) error {  

    return fiber.ErrInternalServerError  

}}))  

  

// In more elaborate scenarios you can also create a custom error which can be processed differently in the fiber.ErrorHandler.  

// See the tests for an example of such an ErrorHandler.  

// You could also just wrap the default handler's error, e.g. fmt.Errorf("[RECOVERED]: %w", recoverer.DefaultPanicHandler(c, r))  

app.Use(recoverer.New(recoverer.Config{PanicHandler: func(c fiber.Ctx, r any) error {  

    return &MyCustomRecoveredFromPanicError {  

        Inner: recoverer.DefaultPanicHandler(c, r),  

    }  

}}))  
```

--------------------------------

### Example Response Output

Source: https://docs.gofiber.io/next/client/rest

The expected JSON response format from the example request.

```json
{
  "args": {},
  ...
}
```

--------------------------------

### Minimal Fiber Application

Source: https://docs.gofiber.io/next/guide/routing

A complete, runnable example of a basic Fiber application.

```go
package main  

  

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

  

func main() {  

    app := fiber.New()  

  

    app.Get("/", func(c fiber.Ctx) error {  

        return c.SendString("Hello, World!")  

    })  

  

    app.Listen(":3000")  

}
```

--------------------------------

### Basic Content Negotiation

Source: https://docs.gofiber.io/next/api/ctx

Examples of using Accepts to match client preferences against server offers.

```go
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")              // ""  

  // ...  

})
```

--------------------------------

### Retry Configuration

Source: https://docs.gofiber.io/next/addon/retry

Examples for initializing the retry addon with default or custom configurations.

```go
retry.NewExponentialBackoff()
```

```go
retry.NewExponentialBackoff(retry.Config{  
    InitialInterval: 2 * time.Second,  
    MaxBackoffTime:  64 * time.Second,  
    Multiplier:      2.0,  
    MaxRetryCount:   15,  
})
```

--------------------------------

### Request Timeout Examples

Source: https://docs.gofiber.io/next/client/request

Demonstrates successful and timed-out requests using SetTimeout.

```go
req := client.AcquireRequest()  

defer client.ReleaseRequest(req)  

  

req.SetTimeout(5 * time.Second)  

  

resp, err := req.Get("https://httpbin.org/delay/4")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))  
```

```json
{  

  "args": {},   

  "data": "",   

  "files": {},   

  "form": {},   

  // ...  

}  
```

```go
req := client.AcquireRequest()  

defer client.ReleaseRequest(req)  

  

req.SetTimeout(5 * time.Second)  

  

resp, err := req.Get("https://httpbin.org/delay/6")  

if err != nil {  

    panic(err)  

}  

  

fmt.Println(string(resp.Body()))  
```

```text
panic: timeout or cancel  

  

goroutine 1 [running]:  

main.main()  

        main.go:18 +0xeb  

exit status 2  
```

--------------------------------

### Mounting a Sub-Application

Source: https://docs.gofiber.io/next/api/app

Complete example showing how to mount a secondary Fiber instance onto a primary application.

```go
package main  

  

import (  

    "log"  

  

    "github.com/gofiber/fiber/v3"  

)  

  

func main() {  

    app := fiber.New()  

    micro := fiber.New()  

  

    // Mount the micro app on the "/john" route  

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

}
```

--------------------------------

### Rewrite Middleware Usage Example

Source: https://docs.gofiber.io/next/middleware/rewrite

Example demonstrating how to use the Rewrite middleware with custom rules.

```APIDOC
## Examples

```go
package main

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

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

	app.Use(rewrite.New(rewrite.Config{
	  Rules: map[string]string{
		"/old":   "/new",
		"/old/*": "/new/$1",
	  },
	}))

	app.Get("/new", func(c fiber.Ctx) error {
	  return c.SendString("Hello, World!")
	})
	app.Get("/new/*", func(c fiber.Ctx) error {
	  return c.SendString("Wildcard: " + c.Params("*"))
	})

	app.Listen(":3000")
}
```
```

--------------------------------

### Service Start Method

Source: https://docs.gofiber.io/next/api/services

Implement this method to define the startup logic for your service. Fiber calls this when the application begins.

```go
func (s *SomeService) Start(ctx context.Context) error  
```

--------------------------------

### Install Fiber Core

Source: https://docs.gofiber.io/next/ecosystem

Use this command to install the Fiber core module as a dependency for your project.

```bash
go get github.com/gofiber/fiber/v3
```

--------------------------------

### Configuring EnvVar Middleware

Source: https://docs.gofiber.io/next/middleware/envvar

Examples of initializing the middleware with default settings or custom exported variables.

```go
// Initialize default config (exports no variables)  

app.Use("/expose/envvars", envvar.New())  

  

// Or extend your config for customization  

app.Use("/expose/envvars", envvar.New(  

    envvar.Config{  

        ExportVars: map[string]string{"testKey": "", "testDefaultKey": "testDefaultVal"},  

    }),  

)
```

--------------------------------

### Custom Storage Integration

Source: https://docs.gofiber.io/next/middleware/limiter

Example of initializing the limiter middleware with a custom storage backend, such as SQLite.

```go
storage := sqlite3.New() // From github.com/gofiber/storage/sqlite3/v2  

  

app.Use(limiter.New(limiter.Config{  

    Storage: storage,  

}))  
```

--------------------------------

### Load Certificates for TLSConfig

Source: https://docs.gofiber.io/next/api/fiber

Examples for loading certificates from memory or environment variables into TLSConfig.

```go
certPEM := []byte(certPEMString)  

keyPEM := []byte(keyPEMString)  

  

cert, err := tls.X509KeyPair(certPEM, keyPEM)  

if err != nil {  

    log.Fatal(err)  

}  

  

app.Listen(":443", fiber.ListenConfig{  

    TLSConfig: &tls.Config{  

        Certificates: []tls.Certificate{cert},  

    },  

})  
```

```go
certPEM := []byte(os.Getenv("TLS_CERT_PEM"))  

keyPEM := []byte(os.Getenv("TLS_KEY_PEM"))  

  

cert, err := tls.X509KeyPair(certPEM, keyPEM)  

if err != nil {  

    log.Fatal(err)  

}  

  

app.Listen(":443", fiber.ListenConfig{  

    TLSConfig: &tls.Config{  

        Certificates: []tls.Certificate{cert},  

    },  

})  
```

--------------------------------

### Configuring Idempotency Middleware

Source: https://docs.gofiber.io/next/middleware/idempotency

Examples for applying default, custom, or method-specific idempotency configurations.

```go
app.Use(idempotency.New())
```

```go
app.Use(idempotency.New(idempotency.Config{  

    Next: func(c fiber.Ctx) bool {  

        // Skip middleware for idempotent methods (safe + PUT, DELETE)  

        return fiber.IsMethodIdempotent(c.Method())  

    },  

}))
```

```go
app.Use(idempotency.New(idempotency.Config{  

    Lifetime: 42 * time.Minute,  

    // ...  

}))
```

--------------------------------

### OnListen Hook Signature and Example

Source: https://docs.gofiber.io/next/api/hooks

Registers a callback that executes when the application starts listening.

```go

func (h *Hooks) OnListen(handler ...OnListenHandler)  


```

```go

package main  

  

import (  

    "log"  

    "os"  

  

    "github.com/gofiber/fiber/v3"  

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

)  

  

func main() {  

    app := fiber.New(fiber.Config{  

        DisableStartupMessage: true,  

    })  

  

    app.Hooks().OnListen(func(listenData fiber.ListenData) error {  

        if fiber.IsChild() {  

            return nil  

        }  

        scheme := "http"  

        if listenData.TLS {  

            scheme = "https"  

        }  

        log.Println(scheme + "://" + listenData.Host + ":" + listenData.Port)  

        return nil  

    })  

  

    app.Listen(":5000")  

}  


```

--------------------------------

### Migrate Utility Function Usage

Source: https://docs.gofiber.io/next/whats_new

Example showing the transition from v2 utility functions to the v3 external module and standard library equivalents.

```go
// v2  

import oldutils "github.com/gofiber/fiber/v2/utils"  

  

func demo() {  

    b := oldutils.TrimBytes([]byte(" fiber "))  

    id := oldutils.UUIDv4()  

    s := oldutils.GetString([]byte("foo"))  

}  

  

// v3  

import (  

    "github.com/gofiber/utils/v2"  

    "strings"  

)  

  

func demo() {  

    s := utils.TrimSpace(" fiber ")  

    id := utils.UUIDv4()  

    str := utils.ToString([]byte("foo"))  

    t := strings.TrimRight("bar  ", " ")  

}
```

--------------------------------

### Domain Routing Implementation

Source: https://docs.gofiber.io/next/whats_new

Examples of using domain-based routing for static hosts, parameters, groups, middleware, and sub-application mounting.

```go
app := fiber.New()  

  

// Static domain  

app.Domain("api.example.com").Get("/users", func(c fiber.Ctx) error {  

    return c.SendString("API users")  

})  

  

// Domain with parameter  

app.Domain(":user.blog.example.com").Get("/", func(c fiber.Ctx) error {  

    user := fiber.DomainParam(c, "user")  

    return c.SendString(user + "'s blog")  

})  

  

// Domain with groups  

api := app.Domain("api.example.com")  

v1 := api.Group("/v1")  

v1.Get("/posts", listPosts)  

  

// Domain with middleware  

admin := app.Domain("admin.example.com")  

admin.Use(authMiddleware)  

admin.Get("/dashboard", dashboardHandler)  

  

// Mount sub-applications on domain routers  

subApp := fiber.New()  

subApp.Get("/users", listUsers)  

app.Domain("api.example.com").Use("/api", subApp)  

  

// Fallback for unmatched domains  

app.Get("/", func(c fiber.Ctx) error {  

    return c.SendString("default site")  

})  
```

--------------------------------

### RouteChain Usage Example

Source: https://docs.gofiber.io/next/whats_new

Demonstrates chaining multiple HTTP methods on a single path using the RouteChain helper.

```go
app.RouteChain("/api").RouteChain("/user/:id?")  

    .Get(func(c fiber.Ctx) error {  

        // Get user  

        return c.JSON(fiber.Map{"message": "Get user", "id": c.Params("id")})  

    })  

    .Post(func(c fiber.Ctx) error {  

        // Create user  

        return c.JSON(fiber.Map{"message": "User created"})  

    })  

    .Put(func(c fiber.Ctx) error {  

        // Update user  

        return c.JSON(fiber.Map{"message": "User updated", "id": c.Params("id")})  

    })  

    .Delete(func(c fiber.Ctx) error {  

        // Delete user  

        return c.JSON(fiber.Map{"message": "User deleted", "id": c.Params("id")})  

    })
```

--------------------------------

### Client initialization methods

Source: https://docs.gofiber.io/next/client/rest

Methods for creating a new client instance, either from scratch or using an existing fasthttp client.

```go
func New() *Client  
```

```go
func NewWithClient(c *fasthttp.Client) *Client  
```

--------------------------------

### SharedState Usage Example

Source: https://docs.gofiber.io/next/api/state

Demonstrates setting and retrieving JSON data in SharedState within route handlers.

```go
type SessionSnapshot struct {  

    UserID    string    `json:"user_id"`  

    UpdatedAt time.Time `json:"updated_at"`  

}  

  

app.Post("/sessions/:id", func(c fiber.Ctx) error {  

    key := "session:" + c.Params("id")  

    value := SessionSnapshot{  

        UserID:    c.Params("id"),  

        UpdatedAt: time.Now().UTC(),  

    }  

  

    if err := app.SharedState().SetJSON(key, value, 30*time.Minute); err != nil {  

        return err  

    }  

  

    return c.SendStatus(fiber.StatusAccepted)  

})  

  

app.Get("/sessions/:id", func(c fiber.Ctx) error {  

    key := "session:" + c.Params("id")  

    var snapshot SessionSnapshot  

  

    _, found, err := app.SharedState().GetJSON(key, &snapshot)  

    if err != nil {  

        return err  

    }  

    if !found {  

        return c.SendStatus(fiber.StatusNotFound)  

    }  

  

    return c.JSON(snapshot)  

})  
```

--------------------------------

### Service Interface Definition

Source: https://docs.gofiber.io/next/api/services

Defines the Service interface that external dependencies must implement to be managed by Fiber. This includes methods for starting, getting the string representation, checking the state, and terminating the service.

```APIDOC
## Service Interface

### Description
The `Service` interface defines methods a service must implement. Fiber starts and stops these services automatically when the application launches and shuts down, respectively. Services can be retrieved from the application's state using `GetService` or `MustGetService`.

### Methods

- **Start**(ctx context.Context) error: Starts the service. Fiber calls this when the application starts.
- **String**() string: Returns a string representation of the service, used for human-readable names in startup messages.
- **State**(ctx context.Context) (string, error): Returns the current state of the service for display in the startup message.
- **Terminate**(ctx context.Context) error: Terminates the service. Fiber calls this during application shutdown.

### Go Code Definition
```go
type Service interface {
    Start(ctx context.Context) error
    String() string
    State(ctx context.Context) (string, error)
    Terminate(ctx context.Context) error
}
```
```

--------------------------------

### Configuring Limiter Middleware

Source: https://docs.gofiber.io/next/middleware/limiter

Examples of initializing the middleware with default settings or a custom configuration including dynamic limits and storage.

```go
// Initialize default config  

app.Use(limiter.New())  

  

// Or extend your config for customization  

app.Use(limiter.New(limiter.Config{  

    Next: func(c fiber.Ctx) bool {  

        return c.IP() == "127.0.0.1"  

    },  

    Max:          20,  

    MaxFunc: func(c fiber.Ctx) int {  

      return 20  

    },  

    Expiration:     30 * time.Second,  

    ExpirationFunc: func(c fiber.Ctx) time.Duration {  

      // Use longer expiration for sensitive endpoints  

      if c.Path() == "/login" {  

        return 60 * time.Second  

      }  

      return 30 * time.Second  

    },  

    KeyGenerator:          func(c fiber.Ctx) string {  

        return c.Get("x-forwarded-for")  

    },  

    LimitReached: func(c fiber.Ctx) error {  

        return c.SendFile("./toofast.html")  

    },  

    Storage: myCustomStorage{},  

}))  
```

--------------------------------

### Basic Logging Examples

Source: https://docs.gofiber.io/next/api/log

Demonstrates how to use the basic level-specific logging methods like Info, Debug, Warn, Error, Fatal, and Panic. The Fatal level will terminate the program.

```go
log.Info("Hello, World!")

log.Debug("Are you OK?")

log.Info("42 is the answer to life, the universe, and everything")

log.Warn("We are under attack!")

log.Error("Houston, we have a problem.")

log.Fatal("So Long, and Thanks for All the Fish.")

log.Panic("The system is down.")
```

--------------------------------

### Get

Source: https://docs.gofiber.io/next/client/request

Sends a GET request to the specified URL.

```APIDOC
## func (r *Request) Get(url string) (*Response, error)

### Description
Sends a GET request to the specified URL. It sets the URL and HTTP method, then dispatches the request to the server.
```

--------------------------------

### Configure Server Listen

Source: https://docs.gofiber.io/next/whats_new

Use fiber.ListenConfig for TLS setup instead of dedicated ListenTLS methods.

```go
// Before  

app.ListenTLS(":3000", "cert.pem", "key.pem")  
```

```go
// After  

app.Listen(":3000", fiber.ListenConfig{  

    CertFile:    "./cert.pem",  

    CertKeyFile: "./key.pem",  

})  
```

--------------------------------

### Perform GET Request

Source: https://docs.gofiber.io/next/client/request

Sends a GET request to the specified URL.

```go
func (r *Request) Get(url string) (*Response, error)
```

--------------------------------

### Common Use method usage patterns

Source: https://docs.gofiber.io/next/guide/routing

Examples of matching all requests, specific prefixes, multiple prefixes, multiple handlers, and mounting sub-apps.

```go
// Match any request  

app.Use(func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match request starting with /api  

app.Use("/api", func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Match requests starting with /api or /home (multiple-prefix support)  

app.Use([]string{"/api", "/home"}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Attach multiple handlers (they run in order; each must call c.Next() to continue)  

app.Use("/api", func(c fiber.Ctx) error {  

    c.Set("X-Custom-Header", "value")  

    return c.Next()  

}, func(c fiber.Ctx) error {  

    return c.Next()  

})  

  

// Mount a sub-app  

app.Use("/api", api)  
```

--------------------------------

### Create a Hello World Server

Source: https://docs.gofiber.io/next

A minimal Fiber application that listens on port 3000 and returns a string response.

```go
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"))

}
```

--------------------------------

### Serving files from a directory

Source: https://docs.gofiber.io/next/middleware/static

This example demonstrates how to serve all static files from the './public' directory for any incoming request.

```APIDOC
## GET /*

### Description
Serves static files from the './public' directory.

### Method
GET

### Endpoint
/*

### Request Example
```go
app.Get("/*", static.New("./public"))
```

### Test
```bash
curl http://localhost:3000/hello.html
curl http://localhost:3000/css/style.css
```
```

--------------------------------

### Implement Server-Side Events with SendStreamWriter

Source: https://docs.gofiber.io/next/whats_new

Example implementation of SSE using the SendStreamWriter method.

```go
app.Get("/sse", func(c fiber.Ctx) error {  

    c.Set("Content-Type", "text/event-stream")  

    c.Set("Cache-Control", "no-cache")  

    c.Set("Connection", "keep-alive")  

    c.Set("Transfer-Encoding", "chunked")  

  

    return c.SendStreamWriter(func(w *bufio.Writer) {  

        for {  

            fmt.Fprintf(w, "event: my-event\n")  

            fmt.Fprintf(w, "data: Hello SSE\n\n")  

  

            if err := w.Flush(); err != nil {  

                log.Print("Client disconnected!")  

                return  

            }  

        }  

    })  

})  
```

--------------------------------

### Query Binding Implementation

Source: https://docs.gofiber.io/next/api/bind

Example of defining a struct with query tags and binding it to a request context.

```go
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.Bind().Query(p); err != nil {  

        return err  

    }  

  

    log.Println(p.Name)     // john  

    log.Println(p.Pass)     // doe  

    // Depending on fiber.Config{EnableSplittingOnParsers: false} - default  

    log.Println(p.Products) // ["shoe,hat"]  

    // With fiber.Config{EnableSplittingOnParsers: true}  

    // log.Println(p.Products) // ["shoe", "hat"]  

  

    // ...  

})
```

--------------------------------

### Migrate to Fiber v3 using CLI

Source: https://docs.gofiber.io/next/whats_new

Install the Fiber CLI tool and execute the migration command to automatically update an existing project to v3.

```bash
go install github.com/gofiber/cli/fiber@latest  

fiber migrate --to v3  
```

--------------------------------

### Redirect Middleware Usage Example

Source: https://docs.gofiber.io/next/middleware/redirect

An example demonstrating how to use the Fiber Redirect middleware with custom rules and status codes.

```APIDOC
## Examples

```go
package main

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

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

	app.Use(redirect.New(redirect.Config{
		Rules: map[string]string{
			"/old":   "/new",
			"/old/*": "/new/$1",
		},
		StatusCode: fiber.StatusMovedPermanently,
	}))

	app.Get("/new", func(c fiber.Ctx) error {
		return c.SendString("Hello, World!")
	})
	app.Get("/new/*", func(c fiber.Ctx) error {
		return c.SendString("Wildcard: " + c.Params("*"))
	})

	app.Listen(":3000")
}
```
```

--------------------------------

### Initialize and use the Fiber REST client

Source: https://docs.gofiber.io/next/client/rest

Demonstrates creating a client instance, setting a timeout, and performing a GET request.

```go
package main  
  
import (  
    "fmt"  
    "time"  
  
    "github.com/gofiber/fiber/v3/client"  
)  
  
func main() {  
    cc := client.New()  
    cc.SetTimeout(10 * time.Second)  
  
    // Send a GET request  
    resp, err := cc.Get("https://httpbin.org/get")  
    if err != nil {  
        panic(err)  
    }  
  
    fmt.Printf("Status: %d\n", resp.StatusCode())  
    fmt.Printf("Body: %s\n", string(resp.Body()))  
}  
```

--------------------------------

### Implement Basic and Parameterized Routes

Source: https://docs.gofiber.io/next

Examples of defining a root path handler and a route that captures dynamic path parameters.

```go
// Respond with "Hello, World!" on root path "/"  

app.Get("/", func(c fiber.Ctx) error {  

    return c.SendString("Hello, World!")  

})  
```

```go
// GET http://localhost:3000/hello%20world  

  

app.Get("/:value", func(c fiber.Ctx) error {  

    return c.SendString("value: " + c.Params("value"))  

    // => Response: "value: hello world"  

})  
```

--------------------------------

### Request Method Accessors

Source: https://docs.gofiber.io/next/client/request

Methods to get or set the HTTP method of a request. Prefer specialized methods like Get or Post over direct SetMethod calls.

```go
func (r *Request) Method() string
```

```go
func (r *Request) SetMethod(method string) *Request
```

--------------------------------

### Defining Users with Prefixed Hashes

Source: https://docs.gofiber.io/next/middleware/basicauth

Example of mapping usernames to their corresponding prefixed password hashes in the configuration.

```go
Users: map[string]string{  

    "john":  "{SHA256}K7gNU3sdo+OL0wNhqoVWhr3g6s1xYv72ol/pe/Unols=",  

    "admin": "{SHA512}vSsar3708Jvp9Szi2NWZZ02Bqp1qRCFpbcTZPdBhnWgs5WtNZKnvCXdhztmeD2cmW192CF5bDufKRpayrW/isg==",  

}  
```

--------------------------------

### Example of Removing and Redefining Routes

Source: https://docs.gofiber.io/next/api/app

Shows how to remove an existing route and redefine it dynamically using RemoveRoute and RebuildTree.

```go
package main  

  

import (  

    "log"  

  

    "github.com/gofiber/fiber/v3"  

)  

  

func main() {  

    app := fiber.New()  

  

    app.Get("/api/feature-a", func(c fiber.Ctx) error {  

           app.RemoveRoute("/api/feature", fiber.MethodGet)  

           app.RebuildTree()  

           // Redefine route  

           app.Get("/api/feature", func(c fiber.Ctx) error {  

                   return c.SendString("Testing feature-a")  

           })  

  

           app.RebuildTree()  

           return c.SendStatus(fiber.StatusOK)  

    })  

    app.Get("/api/feature-b", func(c fiber.Ctx) error {  

           app.RemoveRoute("/api/feature", fiber.MethodGet)  

           app.RebuildTree()  

           // Redefine route  

           app.Get("/api/feature", func(c fiber.Ctx) error {  

                   return c.SendString("Testing feature-b")  

           })  

  

           app.RebuildTree()  

           return c.SendStatus(fiber.StatusOK)  

    })  

  

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

}
```

--------------------------------

### Configure Session Storage Options

Source: https://docs.gofiber.io/next/middleware/session

Set up session storage using Redis or PostgreSQL. Redis is recommended for production environments. Ensure the necessary import paths are included.

```go
import (

    "github.com/gofiber/storage/redis/v3"

    "github.com/gofiber/storage/postgres/v3"

)

// Redis (recommended for production)
redisStorage := redis.New(redis.Config{
    Host:     "localhost",
    Port:     6379,
    Password: "",
    Database: 0,
})

// PostgreSQL
pgStorage := postgres.New(postgres.Config{
    Host:     "localhost",
    Port:     5432,
    Database: "sessions",
    Username: "user",
    Password: "pass",
})

app.Use(session.New(session.Config{
    Storage: redisStorage,
}))
```

--------------------------------

### Get Remote Port

Source: https://docs.gofiber.io/next/api/ctx

Returns the remote port of the request.

```go
// GET http://example.com:8080  

  

app.Get("/", func(c fiber.Ctx) error {  

  c.Port() // "8080"  

  

  // ...  

})
```

--------------------------------

### Initialize a Fiber App

Source: https://docs.gofiber.io/next/api/fiber

Create a new Fiber application instance with default settings.

```go
// Default config  

app := fiber.New()  

  

// ...  
```

--------------------------------

### Get Boundary

Source: https://docs.gofiber.io/next/client/request

Returns the multipart boundary used by the request.

```go
func (r *Request) Boundary() string
```

--------------------------------

### URL and SetURL

Source: https://docs.gofiber.io/next/client/request

Methods to get or set the URL for the request.

```APIDOC
## func (r *Request) URL() string

### Description
Returns the current URL set in the `Request`.

## func (r *Request) SetURL(url string) *Request

### Description
Sets the URL for the `Request` object.
```

--------------------------------

### Get(key string) (any, bool)

Source: https://docs.gofiber.io/next/api/state

Retrieves a value from the State.

```APIDOC
## Get(key string) (any, bool)

### Description
Retrieves a value from the State. Returns the value and a boolean indicating if the key exists.

### Usage
```go
value, ok := app.State().Get("appName")
if ok {
    fmt.Println("App Name:", value)
}
```

--------------------------------

### Basic Host Authorization Setup

Source: https://docs.gofiber.io/next/middleware/hostauthorization

Configure the middleware to allow only specific hosts. Requests with other `Host` headers will be denied.

```go
app.Use(hostauthorization.New(hostauthorization.Config{

    AllowedHosts: []string{"api.myapp.com"},

}))

app.Get("/users", func(c fiber.Ctx) error {

    return c.JSON(getUsers())

})

// Host: api.myapp.com → 200 OK
// Host: evil.com      → 403 Forbidden
```

--------------------------------

### Get Int32 Value

Source: https://docs.gofiber.io/next/api/state

Retrieves an int32 value from the state.

```go

func (s *State) GetInt32(key string) (int32, bool)  


```

```go

if val, ok := app.State().GetInt32("portNumber"); ok {  

    fmt.Printf("Port Number: %d\n", val)  

}  


```

--------------------------------

### Get Int16 Value

Source: https://docs.gofiber.io/next/api/state

Retrieves an int16 value from the state.

```go

func (s *State) GetInt16(key string) (int16, bool)  


```

```go

if val, ok := app.State().GetInt16("minValue"); ok {  

    fmt.Printf("Minimum Value: %d\n", val)  

}  


```

--------------------------------

### Configure Proxy Middleware

Source: https://docs.gofiber.io/next/middleware/proxy

Examples for setting global clients, security policies, request forwarding, and load balancing configurations.

```go
// Use proxy.WithClient to set a global custom client.  
proxy.WithClient(&fasthttp.Client{  
    NoDefaultUserAgentHeader: true,  
    DisablePathNormalizing:   true,  
    MaxConnsPerHost:          2048,  
    // Allow self-signed certificates when proxying to HTTPS targets.  
    // SECURITY: disables certificate verification — use only when the  
    // upstream is on a trusted network.  
    TLSConfig: &tls.Config{  
        InsecureSkipVerify: true,  
        MinVersion:         tls.VersionTLS12,  
    },  
})  
  
// Relax SSRF protection for local development against loopback servers.  
// SECURITY: in production, leave AllowPrivateIPs false (the default) and  
// list explicit upstream hosts so the proxy cannot be coerced into  
// reaching internal services or cloud-metadata endpoints.  
prev := proxy.WithSecurityPolicy(proxy.SecurityPolicy{  
    AllowedSchemes:  []string{"http", "https"},  
    AllowPrivateIPs: true,  
})  
defer proxy.WithSecurityPolicy(prev)  
  
// Forward requests for a specific domain with proxy.DomainForward.  
app.Get("/payments", proxy.DomainForward("docs.gofiber.io", "http://localhost:8000"))  
  
// Forward to a URL using a custom client  
app.Get("/gif", proxy.Forward("https://i.imgur.com/IWaBepg.gif", &fasthttp.Client{  
    NoDefaultUserAgentHeader: true,  
    DisablePathNormalizing:   true,  
}))  
  
// Make a proxied request within a handler  
app.Get("/:id", func(c fiber.Ctx) error {  
    url := "https://i.imgur.com/" + c.Params("id") + ".gif"  
    if err := proxy.Do(c, url); err != nil {  
        return err  
    }  
    // Remove Server header from response  
    c.Response().Header.Del(fiber.HeaderServer)  
    return nil  
})  
  
// Proxy requests while following redirects  
app.Get("/proxy", func(c fiber.Ctx) error {  
    if err := proxy.DoRedirects(c, "http://google.com", 3); err != nil {  
        return err  
    }  
    // Remove Server header from response  
    c.Response().Header.Del(fiber.HeaderServer)  
    return nil  
})  
  
// Proxy requests and wait up to five seconds before timing out  
app.Get("/proxy", func(c fiber.Ctx) error {  
    if err := proxy.DoTimeout(c, "http://localhost:3000", time.Second * 5); err != nil {  
        return err  
    }  
    // Remove Server header from response  
    c.Response().Header.Del(fiber.HeaderServer)  
    return nil  
})  
  
// Proxy requests with a deadline one minute from now  
app.Get("/proxy", func(c fiber.Ctx) error {  
    if err := proxy.DoDeadline(c, "http://localhost", time.Now().Add(time.Minute)); err != nil {  
        return err  
    }  
    // Remove Server header from response  
    c.Response().Header.Del(fiber.HeaderServer)  
    return nil  
})  
  
// Minimal round-robin balancer  
app.Use(proxy.Balancer(proxy.Config{  
    Servers: []string{  
        "http://localhost:3001",  
        "http://localhost:3002",  
        "http://localhost:3003",  
    },  
}))  
  
// Keep the Connection header when proxying  
app.Use(proxy.Balancer(proxy.Config{  
    Servers: []string{  
        "http://localhost:3001",  
    },  
    KeepConnectionHeader: true,  
}))  
  
// Or extend your balancer for customization  
app.Use(proxy.Balancer(proxy.Config{  
    Servers: []string{  
        "http://localhost:3001",  
        "http://localhost:3002",  
        "http://localhost:3003",  
    },  
    MaxConnsPerHost: 2048,  
    ModifyRequest: func(c fiber.Ctx) error {  
        c.Request().Header.Set("X-Real-IP", c.IP())  
        return nil  
    },  
    ModifyResponse: func(c fiber.Ctx) error {  
        c.Response().Header.Del(fiber.HeaderServer)  
        return nil  
    },  
}))  
  
// Or this way if the balancer is using https and the destination server is only using http.  
app.Use(proxy.BalancerForward([]string{  
    "http://localhost:3001",  
    "http://localhost:3002",  
    "http://localhost:3003",  
}))  
  
  
// Make round robin balancer with IPv6 support.  
app.Use(proxy.Balancer(proxy.Config{  
    Servers: []string{  
        "http://[::1]:3001",  
        "http://127.0.0.1:3002",  
        "http://localhost:3003",  
    },  
    // Enable TCP4 and TCP6 network stacks.  
    DialDualStack: true,  
}))  
```

--------------------------------

### Get Int8 Value

Source: https://docs.gofiber.io/next/api/state

Retrieves an int8 value from the state.

```go

func (s *State) GetInt8(key string) (int8, bool)  


```

```go

if val, ok := app.State().GetInt8("threshold"); ok {  

    fmt.Printf("Threshold: %d\n", val)  

}  


```
Tokens:
Raw