beam.RegisterSchemaProvider: unsupported type kind for…

Error message

beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.

What it means

beam.RegisterSchemaProvider only accepts providers for interface, struct, or *struct reflect.Kinds. A pointer to a non-struct is rejected with this panic, since the schema package can only register logical-type providers for those kinds.

Solutions

Pass a struct type or pointer-to-struct to RegisterSchemaProvider (e.g. reflect.TypeOf(MyStruct{}) or &MyStruct{}).
If the target is a pointer to a non-struct, register the underlying struct type instead.
For interfaces, register the interface reflect.Type; for anything else, write a custom coder rather than a schema provider.
Guard registrations with rt.Kind() checks in shared registration helpers.

Example fix

// before
beam.RegisterSchemaProvider(reflect.TypeOf(&myInt), provider) // *int panics
// after
beam.RegisterSchemaProvider(reflect.TypeOf(MyStruct{}), provider)

Defensive patterns

Strategy: validation

Validate before calling

rt := reflect.TypeOf(v)
if k := rt.Kind(); k != reflect.Struct && !(k == reflect.Ptr && rt.Elem().Kind() == reflect.Struct) && k != reflect.Interface {
    return fmt.Errorf("unsupported schema provider kind %v", k)
}

Try / catch

defer func(){ if r := recover(); r != nil && strings.Contains(fmt.Sprint(r), "unsupported type kind for schema provider") { /* fix registration type */ } }()

Prevention

Only register struct, *struct, or interface types
Double-check reflect.TypeOf(&x) targets for non-structs
Validate kinds in shared registration helpers

When it happens

Trigger: Calling beam.RegisterSchemaProvider(rt, provider) with rt = reflect.TypeOf(x) where x is e.g. *int, *string, *map[...], or any pointer to a non-struct type.

Common situations: Typos in generic registration helpers that pass reflect.TypeOf(&someValue) for non-struct values; registering schema providers for primitive aliases or pointers to slices/maps.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

AI-assisted analysis of apache/beam@12126d8942 (2026-09-13). Data as JSON: /api/errors/bcf08bc7d936ba66. Report an issue: GitHub.

Appendix: source

Thrown at sdks/go/pkg/beam/schema.go:64

// Representative Schema types must be structs with only exported fields.
//
// A provider should be thread safe, but it's not required that a produced
// encoder or decoder is thread safe, since a separate encoder or decoder
// will be used for simultaneously executed bundles.
//
// If the supported type is an interface, that interface must have a non-empty
// method set. That is, it cannot be the empty interface.
//
// RegisterSchemaProvider must be called before beam.Init(), and conventionally
// is called in a package init() function.
func RegisterSchemaProvider(rt reflect.Type, provider any) {
	p := provider.(SchemaProvider)
	switch rt.Kind() {
	case reflect.Interface:
		schema.RegisterLogicalTypeProvider(rt, p.FromLogicalType)
	case reflect.Ptr:
		if rt.Elem().Kind() != reflect.Struct {
			panic(fmt.Sprintf("beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.", rt, rt.Kind()))
		}
		fallthrough
	case reflect.Struct:
		st, err := p.FromLogicalType(rt)
		if err != nil {
			panic(fmt.Sprintf("beam.RegisterSchemaProvider: schema type provider for %v, doesn't support that type", rt))
		}
		schema.RegisterLogicalType(schema.ToLogicalType(rt.Name(), rt, st))
	default:
		panic(fmt.Sprintf("beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.", rt, rt.Kind()))
	}

	coder.RegisterSchemaProviders(rt, p.BuildEncoder, p.BuildDecoder)
}

// RegisterSchemaProviderWithURN is for internal use only. Users are recommended to use
// beam.RegisterSchemaProvider() instead.
// RegisterSchemaProviderWithURN registers a new schema provider for a new logical type defined

View on GitHub (pinned to 12126d8942)