diff --git a/docs/release-notes.md b/docs/release-notes.md
index 8e842f0a2..8be710cfe 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -11,6 +11,7 @@ nav_order: 9
 ### Features
 
 - Support partitioning disk with mounted partitions
+- Support IPv6 for single-stack OpenStack
 
 ### Changes
 
diff --git a/internal/providers/openstack/openstack.go b/internal/providers/openstack/openstack.go
index 4ef352cfe..a4d0d539d 100644
--- a/internal/providers/openstack/openstack.go
+++ b/internal/providers/openstack/openstack.go
@@ -22,6 +22,7 @@ package openstack
 import (
 	"context"
 	"fmt"
+	"net"
 	"net/url"
 	"os"
 	"os/exec"
@@ -44,11 +45,15 @@ const (
 )
 
 var (
-	metadataServiceUrl = url.URL{
+	metadataServiceUrlIPv4 = url.URL{
 		Scheme: "http",
 		Host:   "169.254.169.254",
 		Path:   "openstack/latest/user_data",
 	}
+	metadataServiceUrlIPv6 = url.URL{
+		Scheme: "http",
+		Path:   "openstack/latest/user_data",
+	}
 )
 
 func init() {
@@ -166,14 +171,94 @@ func fetchConfigFromDevice(logger *log.Logger, ctx context.Context, path string)
 	return os.ReadFile(filepath.Join(mnt, configDriveUserdataPath))
 }
 
+// Checks if an IP is an IPv6 address
+func isIPv6Address(ip net.IP) bool {
+	isIPv6 := ip.To4() == nil
+	fmt.Printf("Verificando se o IP é IPv6: %s, resultado: %v\n", ip.String(), isIPv6)
+	return isIPv6
+}
+
+// Finds the name of an active network interface
+func findNetworkInterfaceName() (string, error) {
+	fmt.Println("Fetching network interfaces...")
+	interfaces, err := net.Interfaces()
+	if err != nil {
+		return "", fmt.Errorf("error fetching network interfaces: %v", err)
+	}
+
+	for _, iface := range interfaces {
+		fmt.Printf("Checking interface: %s\n", iface.Name)
+
+		// Skip inactive or loopback interfaces
+		if iface.Flags&net.FlagUp != 1 && iface.Flags&net.FlagLoopback == 1 {
+			continue
+		}
+
+		addrs, err := iface.Addrs()
+		if err != nil {
+			fmt.Printf("Error fetching addresses for interface %s: %v\n", iface.Name, err)
+			continue
+		}
+
+		for _, addr := range addrs {
+			if ipnet, ok := addr.(*net.IPNet); ok && isIPv6Address(ipnet.IP) {
+				fmt.Printf("Active interface found: %s\n", iface.Name)
+				return iface.Name, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("no active IPv6 network interface found")
+}
+
+// Fetches configuration from both IPv4 and IPv6 metadata services
 func fetchConfigFromMetadataService(f *resource.Fetcher) ([]byte, error) {
-	res, err := f.FetchToBuffer(metadataServiceUrl, resource.FetchOptions{})
+	var ipv4Res, ipv6Res []byte
+	var ipv4Err, ipv6Err error
 
-	// the metadata server exists but doesn't contain any actual metadata,
-	// assume that there is no config specified
-	if err == resource.ErrNotFound {
-		return nil, nil
+	// Attempt to fetch from IPv4
+	fmt.Println("Fetching from IPv4 metadata service...")
+	ipv4Res, ipv4Err = f.FetchToBuffer(metadataServiceUrlIPv4, resource.FetchOptions{})
+	if ipv4Err == nil {
+		fmt.Println("Successfully fetched configuration from IPv4.")
+
+		// If IPv4 succeeds, attempt to fetch from IPv6 as well
+		fmt.Println("Fetching IPv6 address for metadata service...")
+		interfaceName, err := findNetworkInterfaceName()
+		if err != nil {
+			fmt.Printf("IPv6 metadata service lookup failed: %v\n", err)
+			return ipv4Res, fmt.Errorf("IPv6 lookup failed, returning IPv4 result")
+		}
+
+		metadataServiceUrlIPv6.Host = fmt.Sprintf("fe80::a9fe:a9fe%%%s", interfaceName)
+		fmt.Printf("Fetching from IPv6 metadata service at %s...\n", metadataServiceUrlIPv6.String())
+		ipv6Res, ipv6Err = f.FetchToBuffer(metadataServiceUrlIPv6, resource.FetchOptions{})
+
+		if ipv6Err != nil {
+			fmt.Printf("IPv6 metadata service failed: %v\n", ipv6Err)
+			return ipv4Res, fmt.Errorf("IPv4 succeeded, but IPv6 failed: %v", ipv6Err)
+		}
+		fmt.Println("Successfully fetched configuration from both IPv4 and IPv6.")
+		return append(ipv4Res, ipv6Res...), nil
+	}
+
+	// If IPv4 fails, attempt to fetch from IPv6
+	fmt.Printf("IPv4 metadata service failed: %v\n", ipv4Err)
+	fmt.Println("Trying to fetch from IPv6 metadata service...")
+
+	interfaceName, err := findNetworkInterfaceName()
+	if err != nil {
+		fmt.Printf("IPv6 metadata service lookup failed: %v\n", err)
+		return nil, fmt.Errorf("both IPv4 and IPv6 lookup failed")
+	}
+
+	metadataServiceUrlIPv6.Host = fmt.Sprintf("fe80::a9fe:a9fe%%%s", interfaceName)
+	fmt.Printf("Fetching from IPv6 metadata service at %s...\n", metadataServiceUrlIPv6.String())
+	ipv6Res, ipv6Err = f.FetchToBuffer(metadataServiceUrlIPv6, resource.FetchOptions{})
+	if ipv6Err != nil {
+		fmt.Printf("IPv6 metadata service failed: %v\n", ipv6Err)
+		return nil, fmt.Errorf("both IPv4 and IPv6 services failed")
 	}
 
-	return res, err
+	fmt.Println("Successfully fetched configuration from IPv6 metadata service.")
+	return ipv6Res, fmt.Errorf("IPv4 failed, returning IPv6 result")
 }