diff --git a/openstack/networking/v2/subnets/results.go b/openstack/networking/v2/subnets/results.go
index 2a80f6a..22cff1e 100644
--- a/openstack/networking/v2/subnets/results.go
+++ b/openstack/networking/v2/subnets/results.go
@@ -1,7 +1,6 @@
 package subnets
 
 import (
-	"github.com/mitchellh/mapstructure"
 	"github.com/gophercloud/gophercloud"
 	"github.com/gophercloud/gophercloud/pagination"
 )
@@ -12,17 +11,11 @@
 
 // Extract is a function that accepts a result and extracts a subnet resource.
 func (r commonResult) Extract() (*Subnet, error) {
-	if r.Err != nil {
-		return nil, r.Err
-	}
-
-	var res struct {
+	var s struct {
 		Subnet *Subnet `json:"subnet"`
 	}
-
-	err := mapstructure.Decode(r.Body, &res)
-
-	return res.Subnet, err
+	err := r.ExtractInto(&s)
+	return s.Subnet, err
 }
 
 // CreateResult represents the result of a create operation.
@@ -55,35 +48,35 @@
 // HostRoute represents a route that should be used by devices with IPs from
 // a subnet (not including local subnet route).
 type HostRoute struct {
-	DestinationCIDR string `mapstructure:"destination" json:"destination"`
-	NextHop         string `mapstructure:"nexthop" json:"nexthop"`
+	DestinationCIDR string `json:"destination"`
+	NextHop         string `json:"nexthop"`
 }
 
 // Subnet represents a subnet. See package documentation for a top-level
 // description of what this is.
 type Subnet struct {
 	// UUID representing the subnet
-	ID string `mapstructure:"id" json:"id"`
+	ID string `json:"id"`
 	// UUID of the parent network
-	NetworkID string `mapstructure:"network_id" json:"network_id"`
+	NetworkID string `json:"network_id"`
 	// Human-readable name for the subnet. Might not be unique.
-	Name string `mapstructure:"name" json:"name"`
+	Name string `json:"name"`
 	// IP version, either `4' or `6'
-	IPVersion int `mapstructure:"ip_version" json:"ip_version"`
+	IPVersion int `json:"ip_version"`
 	// CIDR representing IP range for this subnet, based on IP version
-	CIDR string `mapstructure:"cidr" json:"cidr"`
+	CIDR string `json:"cidr"`
 	// Default gateway used by devices in this subnet
-	GatewayIP string `mapstructure:"gateway_ip" json:"gateway_ip"`
+	GatewayIP string `json:"gateway_ip"`
 	// DNS name servers used by hosts in this subnet.
-	DNSNameservers []string `mapstructure:"dns_nameservers" json:"dns_nameservers"`
+	DNSNameservers []string `json:"dns_nameservers"`
 	// Sub-ranges of CIDR available for dynamic allocation to ports. See AllocationPool.
-	AllocationPools []AllocationPool `mapstructure:"allocation_pools" json:"allocation_pools"`
+	AllocationPools []AllocationPool `json:"allocation_pools"`
 	// Routes that should be used by devices with IPs from this subnet (not including local subnet route).
-	HostRoutes []HostRoute `mapstructure:"host_routes" json:"host_routes"`
+	HostRoutes []HostRoute `json:"host_routes"`
 	// Specifies whether DHCP is enabled for this subnet or not.
-	EnableDHCP bool `mapstructure:"enable_dhcp" json:"enable_dhcp"`
+	EnableDHCP bool `json:"enable_dhcp"`
 	// Owner of network. Only admin users can specify a tenant_id other than its own.
-	TenantID string `mapstructure:"tenant_id" json:"tenant_id"`
+	TenantID string `json:"tenant_id"`
 }
 
 // SubnetPage is the page returned by a pager when traversing over a collection
@@ -95,38 +88,30 @@
 // NextPageURL is invoked when a paginated collection of subnets has reached
 // the end of a page and the pager seeks to traverse over a new one. In order
 // to do this, it needs to construct the next page's URL.
-func (p SubnetPage) NextPageURL() (string, error) {
-	type resp struct {
-		Links []gophercloud.Link `mapstructure:"subnets_links"`
+func (page SubnetPage) NextPageURL() (string, error) {
+	var s struct {
+		Links []gophercloud.Link `json:"subnets_links"`
 	}
-
-	var r resp
-	err := mapstructure.Decode(p.Body, &r)
+	err := page.ExtractInto(&s)
 	if err != nil {
 		return "", err
 	}
-
-	return gophercloud.ExtractNextURL(r.Links)
+	return gophercloud.ExtractNextURL(s.Links)
 }
 
 // IsEmpty checks whether a SubnetPage struct is empty.
-func (p SubnetPage) IsEmpty() (bool, error) {
-	is, err := ExtractSubnets(p)
-	if err != nil {
-		return true, nil
-	}
-	return len(is) == 0, nil
+func (page SubnetPage) IsEmpty() (bool, error) {
+	is, err := ExtractSubnets(page)
+	return len(is) == 0, err
 }
 
 // ExtractSubnets accepts a Page struct, specifically a SubnetPage struct,
 // and extracts the elements into a slice of Subnet structs. In other words,
 // a generic collection is mapped into a relevant slice.
 func ExtractSubnets(page pagination.Page) ([]Subnet, error) {
-	var resp struct {
-		Subnets []Subnet `mapstructure:"subnets" json:"subnets"`
+	var s struct {
+		Subnets []Subnet `json:"subnets"`
 	}
-
-	err := mapstructure.Decode(page.(SubnetPage).Body, &resp)
-
-	return resp.Subnets, err
+	err := (page.(SubnetPage)).ExtractInto(&s)
+	return s.Subnets, err
 }