What causes "binder: invalid destination value" in gofiber/fiber?

Ensure the destination is a non-nil pointer to a concrete type before binding: var out MyType; c.Bind().Query(&out).

binder: invalid destination value

Error message

binder: invalid destination value

What it means

Returned by parseToMap (binder/mapping.go:131) when target.IsValid() is false — i.e. the reflect.Value passed in is the zero Value. This happens when the destination is a nil interface{} or nil pointer with no concrete type behind it, so reflection cannot even determine a kind to populate.

Solutions

Ensure the destination is a non-nil pointer to a concrete type before binding: var out MyType; c.Bind().Query(&out).
If the type is dynamic, initialize the interface to a concrete zero value before passing it.
Avoid calling binder.parseToMap directly; use the public Bind.* methods which validate the destination first.

Example fix

// before
var out any // nil interface
err := parseToMap(reflect.ValueOf(out), data) // ErrInvalidDestinationValue

// after
out := map[string]string{}
err := parseToMap(reflect.ValueOf(out), data)

Defensive patterns

Strategy: validation

Validate before calling

// Reject nil-interface destinations before binding
func mustBeConcretePointer(out any) error {
    if out == nil { return errors.New("nil destination") }
    if reflect.ValueOf(out).Kind() != reflect.Ptr { return errors.New("destination must be a pointer") }
    return nil
}

Type guard

func isNonNilPointer(v any) bool {
    return v != nil && reflect.ValueOf(v).Kind() == reflect.Ptr && !reflect.ValueOf(v).IsNil()
}

Try / catch

if err := c.Bind().Query(out); err != nil {
    if errors.Is(err, binder.ErrInvalidDestinationValue) {
        // initialize a concrete zero value and retry
    }
}

Prevention

Never pass a nil interface as a bind destination.
Always bind into a concrete local: var out T; c.Bind().Query(&out).
Avoid calling binder internals directly.

When it happens

Trigger: Calling parseToMap with reflect.ValueOf(nil-interface) or reflect.Value{} directly; passing a nil any as the bind destination through a code path that reaches parseToMap.

Common situations: Binding into an uninitialized `var out any` variable; a nil pointer to a map/struct passed where reflect expects a valid value; misuse of the binder package's internal parseToMap without a concrete destination.

Related errors

AI-assisted analysis of gofiber/fiber@a105acad6c (2026-08-11). Data as JSON: /api/errors/0f1ac8569e508b93. Report an issue: GitHub.

Appendix: source

Thrown at binder/binder.go:22

	"errors"
	"sync"
)

const (
	bindingURI        = "uri"
	bindingForm       = "form"
	bindingQuery      = "query"
	bindingHeader     = "header"
	bindingRespHeader = "respHeader"
	bindingCookie     = "cookie"
)

// Binder errors
var (
	ErrSuitableContentNotFound = errors.New("binder: suitable content not found to parse body")
	ErrMapNotConvertible       = errors.New("binder: map is not convertible to map[string]string or map[string][]string")
	ErrMapNilDestination       = errors.New("binder: map destination is nil and cannot be initialized")
	ErrInvalidDestinationValue = errors.New("binder: invalid destination value")
	ErrUnmatchedBrackets       = errors.New("unmatched brackets")
)

var errPoolTypeAssertion = errors.New("failed to type-assert to T")

var HeaderBinderPool = sync.Pool{
	New: func() any {
		return &HeaderBinding{}
	},
}

var RespHeaderBinderPool = sync.Pool{
	New: func() any {
		return &RespHeaderBinding{}
	},
}

var CookieBinderPool = sync.Pool{

View on GitHub (pinned to a105acad6c)