@@ -451,7 +451,7 @@ type NetworkCreate struct {

 	CheckDuplicate bool                     `json:",omitempty"`

 	Driver         string                   // Driver is the driver-name used to create the network (e.g. `bridge`, `overlay`)

 	Scope          string                   // Scope describes the level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level).

-	EnableIPv6     bool                     // EnableIPv6 represents whether to enable IPv6.

+	EnableIPv6     *bool                    `json:",omitempty"` // EnableIPv6 represents whether to enable IPv6.

 	IPAM           *network.IPAM            // IPAM is the network's IP Address Management.

 	Internal       bool                     // Internal represents if the network is used internal only.

 	Attachable     bool                     // Attachable represents if the global scope is manually attachable by regular containers from workers in swarm mode.

@@ -65,9 +65,10 @@ func TestNetworkCreate(t *testing.T) {

 		}),

 	}

+	enableIPv6 := true

 	networkResponse, err := client.NetworkCreate(context.Background(), "mynetwork", types.NetworkCreate{

 		Driver:     "mydriver",

-		EnableIPv6: true,

+		EnableIPv6: &enableIPv6,

 		Internal:   true,

 		Options: map[string]string{

 			"opt-key": "opt-value",

@@ -195,10 +195,12 @@ func BasicNetworkCreateToGRPC(create basictypes.NetworkCreateRequest) swarmapi.N

 			Name:    create.Driver,

 			Options: create.Options,

 		},

-		Ipv6Enabled: create.EnableIPv6,

-		Internal:    create.Internal,

-		Attachable:  create.Attachable,

-		Ingress:     create.Ingress,

+		Internal:   create.Internal,

+		Attachable: create.Attachable,

+		Ingress:    create.Ingress,

+	}

+	if create.EnableIPv6 != nil {

+		ns.Ipv6Enabled = *create.EnableIPv6

 	}

 	if create.IPAM != nil {

 		driver := create.IPAM.Driver

@@ -621,13 +621,14 @@ func (c *containerConfig) networkCreateRequest(name string) (clustertypes.Networ

 		return clustertypes.NetworkCreateRequest{}, errors.New("container: unknown network referenced")

 	}

+	ipv6Enabled := na.Network.Spec.Ipv6Enabled

 	options := types.NetworkCreate{

 		// ID:     na.Network.ID,

 		Labels:     na.Network.Spec.Annotations.Labels,

 		Internal:   na.Network.Spec.Internal,

 		Attachable: na.Network.Spec.Attachable,

 		Ingress:    convert.IsIngressNetwork(na.Network),

-		EnableIPv6: na.Network.Spec.Ipv6Enabled,

+		EnableIPv6: &ipv6Enabled,

 		Scope:      scope.Swarm,

 	}

@@ -318,8 +318,19 @@ func (daemon *Daemon) createNetwork(cfg *config.Config, create types.NetworkCrea

 		}

 	}

+	var enableIPv6 bool

+	if create.EnableIPv6 != nil {

+		enableIPv6 = *create.EnableIPv6

+	} else {

+		var err error

+		v, ok := networkOptions[netlabel.EnableIPv6]

+		if enableIPv6, err = strconv.ParseBool(v); ok && err != nil {

+			return nil, errdefs.InvalidParameter(fmt.Errorf("driver-opt %q is not a valid bool", netlabel.EnableIPv6))

+		}

+	}

+

 	nwOptions := []libnetwork.NetworkOption{

-		libnetwork.NetworkOptionEnableIPv6(create.EnableIPv6),

+		libnetwork.NetworkOptionEnableIPv6(enableIPv6),

 		libnetwork.NetworkOptionDriverOpts(networkOptions),

 		libnetwork.NetworkOptionLabels(create.Labels),

 		libnetwork.NetworkOptionAttachable(create.Attachable),

@@ -331,7 +342,7 @@ func (daemon *Daemon) createNetwork(cfg *config.Config, create types.NetworkCrea

 		nwOptions = append(nwOptions, libnetwork.NetworkOptionConfigOnly())

 	}

-	if err := network.ValidateIPAM(create.IPAM, create.EnableIPv6); err != nil {

+	if err := network.ValidateIPAM(create.IPAM, enableIPv6); err != nil {

 		if agent {

 			// This function is called with agent=false for all networks. For swarm-scoped

 			// networks, the configuration is validated but ManagerRedirectError is returned

@@ -15,7 +15,8 @@ func WithDriver(driver string) func(*types.NetworkCreate) {

 // WithIPv6 Enables IPv6 on the network

 func WithIPv6() func(*types.NetworkCreate) {

 	return func(n *types.NetworkCreate) {

-		n.EnableIPv6 = true

+		enableIPv6 := true

+		n.EnableIPv6 = &enableIPv6

 	}

 }

@@ -11,6 +11,7 @@ import (

 	"github.com/docker/docker/api/types/versions"

 	ctr "github.com/docker/docker/integration/internal/container"

 	"github.com/docker/docker/integration/internal/network"

+	"github.com/docker/docker/testutil/daemon"

 	"gotest.tools/v3/assert"

 	"gotest.tools/v3/skip"

 )

@@ -68,3 +69,31 @@ func TestCreateWithIPv6DefaultsToULAPrefix(t *testing.T) {

 	t.Fatalf("Network %s has no ULA prefix, expected one.", nwName)

 }

+

+func TestCreateWithIPv6WithoutEnableIPv6Flag(t *testing.T) {

+	skip.If(t, testEnv.DaemonInfo.OSType == "windows") // d.Start fails on Windows with `protocol not available`

+	ctx := setupTest(t)

+

+	d := daemon.New(t)

+	d.StartWithBusybox(ctx, t, "-D", "--default-network-opt=bridge=com.docker.network.enable_ipv6=true")

+	defer d.Stop(t)

+

+	apiClient := d.NewClientT(t)

+	defer apiClient.Close()

+

+	const nwName = "testnetula"

+	network.CreateNoError(ctx, t, apiClient, nwName)

+	defer network.RemoveNoError(ctx, t, apiClient, nwName)

+

+	nw, err := apiClient.NetworkInspect(ctx, "testnetula", networktypes.InspectOptions{})

+	assert.NilError(t, err)

+

+	for _, ipam := range nw.IPAM.Config {

+		ipr := netip.MustParsePrefix(ipam.Subnet)

+		if netip.MustParsePrefix("fd00::/8").Overlaps(ipr) {

+			return

+		}

+	}

+

+	t.Fatalf("Network %s has no ULA prefix, expected one.", nwName)

+}