diff --git a/doc/endpoints.md b/doc/endpoints.md
index dd69067d7..15511049a 100644
--- a/doc/endpoints.md
+++ b/doc/endpoints.md
@@ -44,9 +44,12 @@ SnapshotInfo | GET | /snapshots/{snapname} | [](https://godoc.org/github.com/glu
 SnapshotListAll | GET | /snapshots | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [SnapListResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#SnapListResp)
 SnapshotStatus | GET | /snapshots/{snapname}/status | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [SnapStatusResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#SnapStatusResp)
 SnapshotDelete | DELETE | /snapshots/{snapname} | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
-SnapshotConfigGet | GET | /snapshots/config | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
-SnapshotConfigSet | POST | /snapshots/config | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
-SnapshotConfigReset | DELETE | /snapshots/config | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
+LabelCreate | POST | /snapshots/labels/create | [LabelCreateReq](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelCreateReq) | [LabelCreateResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelCreateResp)
+LabelInfo | GET | snapshots/labels/{labelname} | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [LabelGetResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelGetResp)
+LabelListAll | GET | snapshots/labels/list | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [LabelListResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelListResp)
+LabelDelete | DELETE | snapshots/labels/{labelname} | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
+LabelConfigSet | POST | snapshots/labels/{labelname}/config | [LabelSetReq](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelSetReq) | [LabelConfigResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelConfigResp)
+LabelConfigReset | DELETE | snapshots/labels/{labelname}/config | [LabelResetReq](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelResetReq) | [LabelConfigResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#LabelConfigResp)
 GetPeer | GET | /peers/{peerid} | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [PeerGetResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#PeerGetResp)
 GetPeers | GET | /peers | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [PeerListResp](https://godoc.org/github.com/gluster/glusterd2/pkg/api#PeerListResp)
 DeletePeer | DELETE | /peers/{peerid} | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#) | [](https://godoc.org/github.com/gluster/glusterd2/pkg/api#)
diff --git a/glustercli/cmd/label-create.go b/glustercli/cmd/label-create.go
new file mode 100644
index 000000000..c30ad9523
--- /dev/null
+++ b/glustercli/cmd/label-create.go
@@ -0,0 +1,66 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/gluster/glusterd2/pkg/api"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	labelCreateHelpShort = "Create a label"
+	labelCreateHelpLong  = "Create a label that can use to tag different objects. Label values will be created with default values if choose to omit, specific label values should provide using relevant flags."
+)
+
+var (
+	flagSnapMaxHardLimit uint64
+	flagSnapMaxSoftLimit uint64
+	flagActivateOnCreate bool
+	flagAutoDelete       bool
+	flagDescription      string
+
+	labelCreateCmd = &cobra.Command{
+		Use:   "create <labelname>",
+		Short: labelCreateHelpShort,
+		Long:  labelCreateHelpLong,
+		Args:  cobra.MinimumNArgs(1),
+		Run:   labelCreateCmdRun,
+	}
+)
+
+func init() {
+	labelCreateCmd.Flags().Uint64Var(&flagSnapMaxHardLimit, "snap-max-hard-limit", 256, "Snapshot maximum hard limit count")
+	labelCreateCmd.Flags().Uint64Var(&flagSnapMaxSoftLimit, "snap-max-soft-limit", 230, "Snapshot maximum soft limit count")
+	labelCreateCmd.Flags().BoolVar(&flagActivateOnCreate, "activate-on-create", false, "If enabled, Further snapshots will be activated after creation")
+	labelCreateCmd.Flags().BoolVar(&flagAutoDelete, "auto-delete", false, "If enabled, Snapshots will be deleted upon reaching snap-max-soft-limit. If disabled A warning log will be generated")
+	labelCreateCmd.Flags().StringVar(&flagDescription, "description", "", "Label description")
+
+	labelCmd.AddCommand(labelCreateCmd)
+}
+
+func labelCreateCmdRun(cmd *cobra.Command, args []string) {
+	labelname := args[0]
+
+	req := api.LabelCreateReq{
+		Name:             labelname,
+		SnapMaxHardLimit: flagSnapMaxHardLimit,
+		SnapMaxSoftLimit: flagSnapMaxSoftLimit,
+		ActivateOnCreate: flagActivateOnCreate,
+		AutoDelete:       flagAutoDelete,
+		Description:      flagDescription,
+	}
+
+	info, err := client.LabelCreate(req)
+	if err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).WithFields(
+				log.Fields{
+					"labelname": labelname,
+				}).Error("label creation failed")
+		}
+		failure("Label creation failed", err, 1)
+	}
+	fmt.Printf("%s Label created successfully\n", info.Name)
+}
diff --git a/glustercli/cmd/label-delete.go b/glustercli/cmd/label-delete.go
new file mode 100644
index 000000000..95aceb22f
--- /dev/null
+++ b/glustercli/cmd/label-delete.go
@@ -0,0 +1,38 @@
+package cmd
+
+import (
+	"fmt"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	labelDeleteHelpShort = "Delete labels"
+)
+
+var (
+	labelDeleteCmd = &cobra.Command{
+		Use:   "delete <labelname>",
+		Short: labelDeleteHelpShort,
+		Args:  cobra.ExactArgs(1),
+		Run:   labelDeleteCmdRun,
+	}
+)
+
+func init() {
+	labelCmd.AddCommand(labelDeleteCmd)
+}
+
+func labelDeleteCmdRun(cmd *cobra.Command, args []string) {
+	labelname := args[0]
+
+	if err := client.LabelDelete(labelname); err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).WithField(
+				"label", labelname).Error("label delete failed")
+		}
+		failure("Label delete failed", err, 1)
+	}
+	fmt.Printf("%s Label deleted successfully\n", labelname)
+}
diff --git a/glustercli/cmd/label-info.go b/glustercli/cmd/label-info.go
new file mode 100644
index 000000000..fce58267d
--- /dev/null
+++ b/glustercli/cmd/label-info.go
@@ -0,0 +1,62 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/gluster/glusterd2/pkg/api"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	labelInfoHelpShort = "Get Gluster Label Info"
+)
+
+var (
+	labelInfoCmd = &cobra.Command{
+		Use:   "info <labelname>",
+		Short: labelInfoHelpShort,
+		Args:  cobra.ExactArgs(1),
+		Run:   labelInfoCmdRun,
+	}
+)
+
+func init() {
+	labelCmd.AddCommand(labelInfoCmd)
+}
+
+func labelInfoDisplay(info *api.LabelGetResp) {
+	fmt.Println()
+	fmt.Println("Label Name:", info.Name)
+	fmt.Println("Snap Max Hard Limit:", info.SnapMaxHardLimit)
+	fmt.Println("Snap Max Soft Limit:", info.SnapMaxSoftLimit)
+	fmt.Println("Auto Delete:", info.AutoDelete)
+	fmt.Println("Activate On Create:", info.ActivateOnCreate)
+	fmt.Println("Snapshot List:", info.SnapList)
+	fmt.Println("Description:", info.Description)
+	fmt.Println()
+
+	return
+}
+
+func labelInfoHandler(cmd *cobra.Command) error {
+	var info api.LabelGetResp
+	var err error
+
+	labelname := cmd.Flags().Args()[0]
+	info, err = client.LabelInfo(labelname)
+	if err != nil {
+		return err
+	}
+	labelInfoDisplay(&info)
+	return err
+}
+
+func labelInfoCmdRun(cmd *cobra.Command, args []string) {
+	if err := labelInfoHandler(cmd); err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).Error("error getting label info")
+		}
+		failure("Error getting Label info", err, 1)
+	}
+}
diff --git a/glustercli/cmd/label-list.go b/glustercli/cmd/label-list.go
new file mode 100644
index 000000000..3cd429d3c
--- /dev/null
+++ b/glustercli/cmd/label-list.go
@@ -0,0 +1,61 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/gluster/glusterd2/pkg/api"
+	"github.com/olekukonko/tablewriter"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	helpLabelListCmd = "List all Gluster Labels"
+)
+
+func init() {
+
+	labelCmd.AddCommand(labelListCmd)
+
+}
+
+func labelListHandler(cmd *cobra.Command) error {
+	var infos api.LabelListResp
+	var err error
+
+	infos, err = client.LabelList()
+	if err != nil {
+		return err
+	}
+
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoMergeCells(true)
+	table.SetRowLine(true)
+	if len(infos) == 0 {
+		fmt.Println("There are no labels in the system")
+		return nil
+	}
+	table.SetHeader([]string{"Name"})
+	for _, info := range infos {
+		table.Append([]string{info.Name})
+	}
+	table.Render()
+	return err
+}
+
+var labelListCmd = &cobra.Command{
+	Use:   "list",
+	Short: helpLabelListCmd,
+	Args:  cobra.NoArgs,
+	Run:   labelListCmdRun,
+}
+
+func labelListCmdRun(cmd *cobra.Command, args []string) {
+	if err := labelListHandler(cmd); err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).Error("error getting label list")
+		}
+		failure("Error getting Label list", err, 1)
+	}
+}
diff --git a/glustercli/cmd/label-reset.go b/glustercli/cmd/label-reset.go
new file mode 100644
index 000000000..6fb458880
--- /dev/null
+++ b/glustercli/cmd/label-reset.go
@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/gluster/glusterd2/pkg/api"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	labelResetCmdHelpShort = "Reset value of  label configuratio options"
+	labelResetCmdHelpLong  = "Reset options on a specified gluster snapshot label. Needs a label name and at least one option"
+)
+
+var labelResetCmd = &cobra.Command{
+	Use:   "reset <labelname> <options>",
+	Short: labelResetCmdHelpShort,
+	Long:  labelResetCmdHelpLong,
+	Args:  cobra.RangeArgs(1, 2),
+	Run: func(cmd *cobra.Command, args []string) {
+		var req api.LabelResetReq
+		labelname := args[0]
+		options := args[1:]
+		if len(args) < 2 {
+			failure("Specify atleast one label option to reset", errors.New("Specify atleast one label option to reset"), 1)
+		} else {
+			req.Configurations = options
+		}
+
+		err := client.LabelReset(req, labelname)
+		if err != nil {
+			if GlobalFlag.Verbose {
+				log.WithError(err).WithField("label", labelname).Error("label reset failed")
+			}
+			failure("Snapshot label reset failed", err, 1)
+		}
+		fmt.Printf("Snapshot label options reset successfully\n")
+	},
+}
+
+func init() {
+	labelCmd.AddCommand(labelResetCmd)
+}
diff --git a/glustercli/cmd/label-set.go b/glustercli/cmd/label-set.go
new file mode 100644
index 000000000..e7079ebeb
--- /dev/null
+++ b/glustercli/cmd/label-set.go
@@ -0,0 +1,73 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/gluster/glusterd2/pkg/api"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	labelSetHelpShort = "Set a label value"
+	labelSetHelpLong  = "Modify one or more label value ."
+)
+
+var (
+	labelSetCmd = &cobra.Command{
+		Use:   "set <labelname> <option> <value> [<option> <value>]...",
+		Short: labelSetHelpShort,
+		Long:  labelSetHelpLong,
+		Args:  labelSetArgsValidate,
+		Run:   labelSetCmdRun,
+	}
+)
+
+func labelSetArgsValidate(cmd *cobra.Command, args []string) error {
+	// Ensure we have enough arguments for the command
+	if len(args) < 3 {
+		return errors.New("need at least 3 arguments")
+	}
+
+	// Ensure we have a proper option-value pairs
+	if (len(args)-1)%2 != 0 {
+		return errors.New("needs '<option> <value>' to be in pairs")
+	}
+
+	return nil
+}
+
+func init() {
+	labelCmd.AddCommand(labelSetCmd)
+}
+
+func labelSetCmdRun(cmd *cobra.Command, args []string) {
+	labelname := args[0]
+	options := args[1:]
+
+	if err := labelSetHandler(cmd, labelname, options); err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).WithField(
+				"labelname", labelname).Error("label set failed")
+		}
+		failure("Label set failed", err, 1)
+	} else {
+		fmt.Printf("Label Values set successfully for %s label\n", labelname)
+	}
+
+}
+
+func labelSetHandler(cmd *cobra.Command, labelname string, options []string) error {
+	confs := make(map[string]string)
+	for op, val := range options {
+		if op%2 == 0 {
+			confs[val] = options[op+1]
+		}
+	}
+	req := api.LabelSetReq{
+		Configurations: confs,
+	}
+	err := client.LabelSet(req, labelname)
+	return err
+}
diff --git a/glustercli/cmd/labels.go b/glustercli/cmd/labels.go
new file mode 100644
index 000000000..42afaf38c
--- /dev/null
+++ b/glustercli/cmd/labels.go
@@ -0,0 +1,18 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+const (
+	helpLabelCmd = "Snapshot Label Management"
+)
+
+var labelCmd = &cobra.Command{
+	Use:   "label",
+	Short: helpLabelCmd,
+}
+
+func init() {
+	snapshotCmd.AddCommand(labelCmd)
+}
diff --git a/glustercli/cmd/snapshot-create.go b/glustercli/cmd/snapshot-create.go
index e9f25ab0b..df369c0e4 100644
--- a/glustercli/cmd/snapshot-create.go
+++ b/glustercli/cmd/snapshot-create.go
@@ -18,6 +18,7 @@ var (
 	flagSnapshotCreateForce       bool
 	flagSnapshotCreateTimestamp   bool
 	flagSnapshotCreateDescription string
+	flagSnapshotCreateLabel       string
 
 	snapshotCreateCmd = &cobra.Command{
 		Use:   "create <snapname> <volname>",
@@ -32,6 +33,7 @@ func init() {
 	snapshotCreateCmd.Flags().StringVar(&flagSnapshotCreateDescription, "description", "", "Description of snapshot")
 	snapshotCreateCmd.Flags().BoolVar(&flagSnapshotCreateForce, "force", false, "Force")
 	snapshotCreateCmd.Flags().BoolVar(&flagSnapshotCreateTimestamp, "timestamp", false, "Append timestamp with snap name")
+	snapshotCreateCmd.Flags().StringVar(&flagSnapshotCreateLabel, "label", "defaultLabel", "Label name for the snapshot")
 
 	snapshotCmd.AddCommand(snapshotCreateCmd)
 }
@@ -46,6 +48,7 @@ func snapshotCreateCmdRun(cmd *cobra.Command, args []string) {
 		Force:       flagSnapshotCreateForce,
 		TimeStamp:   flagSnapshotCreateTimestamp,
 		Description: flagSnapshotCreateDescription,
+		SnapLabel:   flagSnapshotCreateLabel,
 	}
 
 	snap, err := client.SnapshotCreate(req)
diff --git a/glustercli/cmd/snapshot-delete.go b/glustercli/cmd/snapshot-delete.go
index 6b33c25a9..c9ef0f27b 100644
--- a/glustercli/cmd/snapshot-delete.go
+++ b/glustercli/cmd/snapshot-delete.go
@@ -3,8 +3,6 @@ package cmd
 import (
 	"fmt"
 
-	"github.com/gluster/glusterd2/pkg/api"
-
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
@@ -27,11 +25,13 @@ var (
 )
 
 var (
-	snapshotDeleteAllCmd = &cobra.Command{
-		Use:   "all [volname]",
+	flagSnapshotDeleteAllVolume string
+	flagSnapshotDeleteAllLabel  string
+	snapshotDeleteAllCmd        = &cobra.Command{
+		Use:   "all",
 		Short: snapshotDeleteAllHelpShort,
 		Long:  snapshotDeleteAllHelpLong,
-		Args:  cobra.MaximumNArgs(1),
+		Args:  cobra.MaximumNArgs(0),
 		Run:   snapshotDeleteAllCmdRun,
 	}
 )
@@ -39,6 +39,8 @@ var (
 func init() {
 	snapshotCmd.AddCommand(snapshotDeleteCmd)
 	snapshotDeleteCmd.AddCommand(snapshotDeleteAllCmd)
+	snapshotDeleteAllCmd.Flags().StringVar(&flagSnapshotDeleteAllVolume, "volume", "", "Deletes all snapshots of a given volume")
+	snapshotDeleteAllCmd.Flags().StringVar(&flagSnapshotDeleteAllLabel, "label", "", "Deletes all snapshots attached to the label")
 }
 
 func snapshotDelete(snapname string) error {
@@ -60,21 +62,40 @@ func snapshotDeleteCmdRun(cmd *cobra.Command, args []string) {
 	}
 }
 
+func deleteAllSnapshots(snapList []string) {
+	for _, snap := range snapList {
+		if err := snapshotDelete(snap); err != nil {
+			fmt.Printf("Failed to delete snapshot %s \n", snap)
+		}
+	}
+}
+
 func snapshotDeleteAllCmdRun(cmd *cobra.Command, args []string) {
-	var snaps api.SnapListResp
 	var err error
-	volname := ""
-	if len(args) > 0 {
-		volname = args[0]
+	volname := flagSnapshotDeleteAllVolume
+	labelname := flagSnapshotDeleteAllLabel
+
+	if labelname != "" {
+		info, err := client.LabelInfo(labelname)
+		if err != nil {
+			failure("Failed to get all snapshots", err, 1)
+		}
+		fmt.Printf("Deleting All snapshots of label %s \n", labelname)
+		deleteAllSnapshots(info.SnapList)
+		if volname != "" {
+			//If volume falg has not given then we are done with
+			//delete all.
+			return
+		}
 	}
 
-	snaps, err = client.SnapshotList(volname)
+	snaps, err := client.SnapshotList(volname)
 	if err != nil {
 		failure("Failed to get all snapshots", err, 1)
 	}
 
 	if len(snaps) == 0 {
-		fmt.Printf("There are no snapshots to delete \n")
+		fmt.Printf("There are no more snapshots to delete \n")
 		return
 	}
 
diff --git a/glustercli/cmd/snapshot-info.go b/glustercli/cmd/snapshot-info.go
index 353c65b52..8389866cc 100644
--- a/glustercli/cmd/snapshot-info.go
+++ b/glustercli/cmd/snapshot-info.go
@@ -27,21 +27,6 @@ func init() {
 
 func snapshotInfoDisplay(snap api.SnapGetResp) {
 	vol := &snap.VolInfo
-	/*
-		data := [][]string{
-			{vol.Name, vol.Name},
-			{"Snapshot Volume ID:", fmt.Sprintln(vol.ID)},
-			{"State:", fmt.Sprintln(vol.State)},
-			{"Origin Volume name:", snap.ParentVolName},
-			{"Snap Creation Time:", "To Be Added"},
-			{"Labels:", "To Be Added"},
-		}
-		table := tablewriter.NewWriter(os.Stdout)
-		table.SetAutoMergeCells(true)
-		table.AppendBulk(data)
-		table.Render()
-		//	table.Append([]string{"Snapshot Volume ID:", string(vol.ID)})
-	*/
 	fmt.Println()
 	fmt.Println("Snapshot Name:", vol.Name)
 	fmt.Println("Snapshot Volume ID:", vol.ID)
@@ -51,7 +36,7 @@ func snapshotInfoDisplay(snap api.SnapGetResp) {
 	if vol.Capacity != 0 {
 		fmt.Println("Snapshot Volume Capactiy: ", humanReadable(vol.Capacity))
 	}
-	fmt.Println("Labels:", "To Be Added")
+	fmt.Println("Label:", snap.SnapLabel)
 	fmt.Println("Snapshot Description:", snap.Description)
 	fmt.Println()
 
diff --git a/glusterd2/commands/snapshot/commands.go b/glusterd2/commands/snapshot/commands.go
index ede9eee3a..ccc8bfe44 100644
--- a/glusterd2/commands/snapshot/commands.go
+++ b/glusterd2/commands/snapshot/commands.go
@@ -1,10 +1,7 @@
 package snapshotcommands
 
 import (
-	"net/http"
-
 	"github.com/gluster/glusterd2/glusterd2/servers/rest/route"
-	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
 	"github.com/gluster/glusterd2/pkg/api"
 	"github.com/gluster/glusterd2/pkg/utils"
 )
@@ -81,41 +78,52 @@ func (c *Command) Routes() route.Routes {
 			Version:     1,
 			HandlerFunc: snapshotDeleteHandler},
 		route.Route{
-			Name:        "SnapshotConfigGet",
-			Method:      "GET",
-			Pattern:     "/snapshots/config",
-			Version:     1,
-			HandlerFunc: snapshotConfigGetHandler},
+			Name:         "LabelCreate",
+			Method:       "POST",
+			Pattern:      "/snapshots/labels/create",
+			Version:      1,
+			RequestType:  utils.GetTypeString((*api.LabelCreateReq)(nil)),
+			ResponseType: utils.GetTypeString((*api.LabelCreateResp)(nil)),
+			HandlerFunc:  labelCreateHandler},
 		route.Route{
-			Name:        "SnapshotConfigSet",
-			Method:      "POST",
-			Pattern:     "/snapshots/config",
-			Version:     1,
-			HandlerFunc: snapshotConfigSetHandler},
+			Name:         "LabelInfo",
+			Method:       "GET",
+			Pattern:      "/snapshots/labels/{labelname}",
+			Version:      1,
+			ResponseType: utils.GetTypeString((*api.LabelGetResp)(nil)),
+			HandlerFunc:  labelInfoHandler},
+		route.Route{
+			Name:         "LabelListAll",
+			Method:       "GET",
+			Pattern:      "/snapshots/labels/list/all",
+			Version:      1,
+			ResponseType: utils.GetTypeString((*api.LabelListResp)(nil)),
+			HandlerFunc:  labelListHandler},
 		route.Route{
-			Name:        "SnapshotConfigReset",
+			Name:        "LabelDelete",
 			Method:      "DELETE",
-			Pattern:     "/snapshots/config",
+			Pattern:     "/snapshots/labels/{labelname}",
 			Version:     1,
-			HandlerFunc: snapshotConfigResetHandler},
+			HandlerFunc: labelDeleteHandler},
+		route.Route{
+			Name:         "LabelConfigSet",
+			Method:       "POST",
+			Pattern:      "/snapshots/labels/{labelname}/config",
+			Version:      1,
+			RequestType:  utils.GetTypeString((*api.LabelSetReq)(nil)),
+			ResponseType: utils.GetTypeString((*api.LabelConfigResp)(nil)),
+			HandlerFunc:  labelConfigSetHandler},
+		route.Route{
+			Name:         "LabelConfigReset",
+			Method:       "DELETE",
+			Pattern:      "/snapshots/labels/{labelname}/config",
+			Version:      1,
+			RequestType:  utils.GetTypeString((*api.LabelResetReq)(nil)),
+			ResponseType: utils.GetTypeString((*api.LabelConfigResp)(nil)),
+			HandlerFunc:  labelConfigResetHandler},
 	}
 }
 
-func snapshotConfigGetHandler(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	restutils.SendHTTPResponse(ctx, w, http.StatusNotImplemented, "Snapshot Config Get")
-}
-
-func snapshotConfigSetHandler(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	restutils.SendHTTPResponse(ctx, w, http.StatusNotImplemented, "Snapshot Config Set")
-}
-
-func snapshotConfigResetHandler(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	restutils.SendHTTPResponse(ctx, w, http.StatusNotImplemented, "Snapshot Config Reset")
-}
-
 // RegisterStepFuncs registers transaction step functions with
 // Glusterd Transaction framework
 func (c *Command) RegisterStepFuncs() {
@@ -126,5 +134,9 @@ func (c *Command) RegisterStepFuncs() {
 	registerSnapshotStatusStepFuncs()
 	registerSnapRestoreStepFuncs()
 	registerSnapCloneStepFuncs()
+	registerLabelCreateStepFuncs()
+	registerLabelDeleteStepFuncs()
+	registerLabelConfigSetStepFuncs()
+	registerLabelConfigResetStepFuncs()
 	return
 }
diff --git a/glusterd2/commands/snapshot/label-create.go b/glusterd2/commands/snapshot/label-create.go
new file mode 100644
index 000000000..3a4f2b556
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-create.go
@@ -0,0 +1,143 @@
+package snapshotcommands
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/gluster/glusterd2/glusterd2/gdctx"
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/glusterd2/transaction"
+	"github.com/gluster/glusterd2/pkg/api"
+	gderrors "github.com/gluster/glusterd2/pkg/errors"
+
+	"github.com/pborman/uuid"
+)
+
+const maxSnapCount = 256
+
+//LoadDefaultLabel will store default label into etcd store. If already present then will not do anything
+func LoadDefaultLabel() error {
+	labelInfo := label.DefaultLabel
+
+	if label.ExistsFunc(labelInfo.Name) {
+		return nil
+	}
+
+	err := label.AddOrUpdateLabelFunc(&labelInfo)
+	return err
+}
+
+func validateLabel(info *label.Info) error {
+
+	if info.SnapMaxHardLimit > maxSnapCount {
+		return fmt.Errorf("Snap-max-hard-limit count cannot exceed more than %d", maxSnapCount)
+	}
+	if info.SnapMaxSoftLimit > info.SnapMaxHardLimit {
+		return errors.New("snap-soft-limit cannot exceed more than snap-max-hard-limit")
+	}
+	return nil
+}
+
+func newLabelInfo(req *api.LabelCreateReq) *label.Info {
+	var labelInfo label.Info
+
+	labelInfo.Name = req.Name
+	labelInfo.SnapMaxHardLimit = req.SnapMaxHardLimit
+	labelInfo.SnapMaxSoftLimit = req.SnapMaxSoftLimit
+	labelInfo.ActivateOnCreate = req.ActivateOnCreate
+	labelInfo.AutoDelete = req.AutoDelete
+	labelInfo.Description = req.Description
+
+	return &labelInfo
+}
+
+func storeLabel(c transaction.TxnCtx) error {
+
+	var labelInfo label.Info
+
+	if err := c.Get("label", &labelInfo); err != nil {
+		return err
+	}
+	if err := label.AddOrUpdateLabelFunc(&labelInfo); err != nil {
+		c.Logger().WithError(err).WithField(
+			"label", labelInfo.Name).Debug("storeLabel: failed to store label info")
+		return err
+	}
+
+	return nil
+}
+
+func registerLabelCreateStepFuncs() {
+	transaction.RegisterStepFunc(storeLabel, "label-create.Store")
+}
+
+func labelCreateHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	logger := gdctx.GetReqLogger(ctx)
+	var req api.LabelCreateReq
+
+	if err := restutils.UnmarshalRequest(r, &req); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, gderrors.ErrJSONParsingFailed)
+		return
+	}
+	if label.ExistsFunc(req.Name) {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, gderrors.ErrLabelExists)
+		return
+	}
+
+	/*
+		TODO : label name validation
+	*/
+
+	labelInfo := newLabelInfo(&req)
+	if err := validateLabel(labelInfo); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, err)
+		return
+	}
+
+	txn, err := transaction.NewTxnWithLocks(ctx, req.Name)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+	defer txn.Done()
+
+	txn.Steps = []*transaction.Step{
+		{
+			DoFunc: "label-create.Store",
+			Nodes:  []uuid.UUID{gdctx.MyUUID},
+		},
+	}
+
+	if err = txn.Ctx.Set("label", &labelInfo); err != nil {
+		logger.WithError(err).Error("failed to set request in transaction context")
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	if err = txn.Do(); err != nil {
+		logger.WithError(err).Error("label create transaction failed")
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	labelInfo, err = label.GetLabel(req.Name)
+	if err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	txn.Ctx.Logger().WithField("LabelName", req.Name).Info("new label created")
+
+	resp := createLabelCreateResp(labelInfo)
+	restutils.SetLocationHeader(r, w, labelInfo.Name)
+	restutils.SendHTTPResponse(ctx, w, http.StatusCreated, resp)
+}
+
+func createLabelCreateResp(info *label.Info) *api.LabelCreateResp {
+	return (*api.LabelCreateResp)(label.CreateLabelInfoResp(info))
+}
diff --git a/glusterd2/commands/snapshot/label-delete.go b/glusterd2/commands/snapshot/label-delete.go
new file mode 100644
index 000000000..8fc6a76a9
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-delete.go
@@ -0,0 +1,83 @@
+package snapshotcommands
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gluster/glusterd2/glusterd2/gdctx"
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/glusterd2/transaction"
+	"github.com/gorilla/mux"
+	"github.com/pborman/uuid"
+)
+
+func registerLabelDeleteStepFuncs() {
+	transaction.RegisterStepFunc(deleteLabel, "label-delete.Store")
+}
+
+func deleteLabel(c transaction.TxnCtx) error {
+
+	var labelInfo label.Info
+	if err := c.Get("labelinfo", &labelInfo); err != nil {
+		return err
+	}
+
+	err := label.DeleteLabel(&labelInfo)
+	return err
+}
+
+func labelDeleteHandler(w http.ResponseWriter, r *http.Request) {
+
+	ctx := r.Context()
+	logger := gdctx.GetReqLogger(ctx)
+
+	labelname := mux.Vars(r)["labelname"]
+	labelInfo, err := label.GetLabel(labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	txn, err := transaction.NewTxnWithLocks(ctx, labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+	defer txn.Done()
+
+	if labelname == (label.DefaultLabel).Name {
+		errMsg := "Default label cannot be deleted."
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, errMsg)
+		return
+	}
+
+	if len(labelInfo.SnapList) > 0 {
+		errMsg := fmt.Sprintf("Cannot delete Label %s ,as it has %d snapshots tagged.", labelname, len(labelInfo.SnapList))
+		restutils.SendHTTPError(ctx, w, http.StatusFailedDependency, errMsg)
+		return
+	}
+	txn.Steps = []*transaction.Step{
+		{
+			DoFunc: "label-delete.Store",
+			Nodes:  []uuid.UUID{gdctx.MyUUID},
+		},
+	}
+
+	if err := txn.Ctx.Set("labelinfo", labelInfo); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	if err := txn.Do(); err != nil {
+		logger.WithError(err).WithField(
+			"label", labelname).Error("transaction to delete label failed")
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	logger.WithField("label-name", labelname).Info("label deleted")
+	restutils.SendHTTPResponse(ctx, w, http.StatusNoContent, nil)
+}
diff --git a/glusterd2/commands/snapshot/label-info.go b/glusterd2/commands/snapshot/label-info.go
new file mode 100644
index 000000000..faec441fe
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-info.go
@@ -0,0 +1,30 @@
+package snapshotcommands
+
+import (
+	"net/http"
+
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/pkg/api"
+	"github.com/gorilla/mux"
+)
+
+func labelInfoHandler(w http.ResponseWriter, r *http.Request) {
+
+	ctx := r.Context()
+
+	labelname := mux.Vars(r)["labelname"]
+	labelInfo, err := label.GetLabel(labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	resp := createLabelGetResp(labelInfo)
+	restutils.SendHTTPResponse(ctx, w, http.StatusOK, resp)
+}
+
+func createLabelGetResp(info *label.Info) *api.LabelGetResp {
+	return (*api.LabelGetResp)(label.CreateLabelInfoResp(info))
+}
diff --git a/glusterd2/commands/snapshot/label-list.go b/glusterd2/commands/snapshot/label-list.go
new file mode 100644
index 000000000..58bb737a4
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-list.go
@@ -0,0 +1,34 @@
+package snapshotcommands
+
+import (
+	"net/http"
+
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/pkg/api"
+)
+
+func labelListHandler(w http.ResponseWriter, r *http.Request) {
+
+	ctx := r.Context()
+
+	labelInfos, err := label.GetLabels()
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	resp := createLabelListResp(labelInfos)
+	restutils.SendHTTPResponse(ctx, w, http.StatusOK, resp)
+}
+
+func createLabelListResp(infos []*label.Info) *api.LabelListResp {
+	var resp = make(api.LabelListResp, len(infos))
+
+	for index, v := range infos {
+		resp[index] = *(createLabelGetResp(v))
+	}
+
+	return &resp
+}
diff --git a/glusterd2/commands/snapshot/label-reset.go b/glusterd2/commands/snapshot/label-reset.go
new file mode 100644
index 000000000..d13d727b3
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-reset.go
@@ -0,0 +1,118 @@
+package snapshotcommands
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gluster/glusterd2/glusterd2/gdctx"
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/glusterd2/transaction"
+	"github.com/gluster/glusterd2/pkg/api"
+	gderrors "github.com/gluster/glusterd2/pkg/errors"
+	"github.com/gorilla/mux"
+
+	"github.com/pborman/uuid"
+)
+
+func updateResetLabel(labelInfo *label.Info, req *api.LabelResetReq) (*label.Info, error) {
+
+	for _, v := range req.Configurations {
+		switch label.Options(v) {
+		case label.SnapMaxHardLimitKey:
+			labelInfo.SnapMaxHardLimit = label.DefaultLabel.SnapMaxHardLimit
+		case label.SnapMaxSoftLimitKey:
+			labelInfo.SnapMaxSoftLimit = label.DefaultLabel.SnapMaxSoftLimit
+		case label.ActivateOnCreateKey:
+			labelInfo.ActivateOnCreate = label.DefaultLabel.ActivateOnCreate
+		case label.AutoDeleteKey:
+			labelInfo.AutoDelete = label.DefaultLabel.AutoDelete
+		default:
+			return labelInfo, fmt.Errorf("%s is not a comptable ioption", v)
+
+		}
+
+	}
+	return labelInfo, nil
+}
+
+func registerLabelConfigResetStepFuncs() {
+	transaction.RegisterStepFunc(storeLabel, "label-config.Store")
+}
+
+func labelConfigResetHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	logger := gdctx.GetReqLogger(ctx)
+	var req api.LabelResetReq
+
+	if err := restutils.UnmarshalRequest(r, &req); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, gderrors.ErrJSONParsingFailed)
+		return
+	}
+
+	labelname := mux.Vars(r)["labelname"]
+
+	if labelname == (label.DefaultLabel).Name {
+		errMsg := "Default label cannot be edited."
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, errMsg)
+		return
+	}
+
+	txn, err := transaction.NewTxnWithLocks(ctx, labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+	defer txn.Done()
+
+	labelInfo, err := label.GetLabel(labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	if err := validateLabel(labelInfo); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, err)
+		return
+	}
+
+	labelInfo, err = updateResetLabel(labelInfo, &req)
+	if err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, err)
+		return
+	}
+
+	txn.Steps = []*transaction.Step{
+		{
+			DoFunc: "label-config.Store",
+			Nodes:  []uuid.UUID{gdctx.MyUUID},
+		},
+	}
+
+	if err = txn.Ctx.Set("label", &labelInfo); err != nil {
+		logger.WithError(err).Error("failed to set request in transaction context")
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	if err = txn.Do(); err != nil {
+		logger.WithError(err).Error("label config transaction failed")
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	labelInfo, err = label.GetLabel(labelname)
+	if err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	txn.Ctx.Logger().WithField("LabelName", labelname).Info("label modfied")
+
+	resp := createLabelConfigResp(labelInfo)
+	restutils.SetLocationHeader(r, w, labelInfo.Name)
+	restutils.SendHTTPResponse(ctx, w, http.StatusNoContent, resp)
+}
diff --git a/glusterd2/commands/snapshot/label-set.go b/glusterd2/commands/snapshot/label-set.go
new file mode 100644
index 000000000..5ad7a22bc
--- /dev/null
+++ b/glusterd2/commands/snapshot/label-set.go
@@ -0,0 +1,139 @@
+package snapshotcommands
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/gluster/glusterd2/glusterd2/gdctx"
+	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
+	"github.com/gluster/glusterd2/glusterd2/transaction"
+	"github.com/gluster/glusterd2/pkg/api"
+	gderrors "github.com/gluster/glusterd2/pkg/errors"
+	"github.com/gorilla/mux"
+
+	"github.com/pborman/uuid"
+)
+
+func updateSetLabel(labelInfo *label.Info, req *api.LabelSetReq) (*label.Info, error) {
+
+	for k, v := range req.Configurations {
+		switch label.Options(k) {
+		case label.SnapMaxHardLimitKey:
+			value, err := strconv.ParseUint(v, 10, 64)
+			if err != nil {
+				return labelInfo, fmt.Errorf("%s is not a comptable value for option %s", v, k)
+			}
+			labelInfo.SnapMaxHardLimit = value
+		case label.SnapMaxSoftLimitKey:
+			value, err := strconv.ParseUint(v, 10, 64)
+			if err != nil {
+				return labelInfo, fmt.Errorf("%s is not a comptable value for option %s", v, k)
+			}
+			labelInfo.SnapMaxSoftLimit = value
+		case label.ActivateOnCreateKey:
+			value, err := strconv.ParseBool(v)
+			if err != nil {
+				return labelInfo, fmt.Errorf("%s is not a comptable value for option %s", v, k)
+			}
+			labelInfo.ActivateOnCreate = value
+		case label.AutoDeleteKey:
+			value, err := strconv.ParseBool(v)
+			if err != nil {
+				return labelInfo, fmt.Errorf("%s is not a comptable value for option %s", v, k)
+			}
+			labelInfo.AutoDelete = value
+		default:
+			return labelInfo, fmt.Errorf("%s is not a comptable option", k)
+
+		}
+
+	}
+	return labelInfo, nil
+}
+
+func registerLabelConfigSetStepFuncs() {
+	transaction.RegisterStepFunc(storeLabel, "label-config.Store")
+}
+
+func labelConfigSetHandler(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	logger := gdctx.GetReqLogger(ctx)
+	var req api.LabelSetReq
+
+	if err := restutils.UnmarshalRequest(r, &req); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, gderrors.ErrJSONParsingFailed)
+		return
+	}
+
+	labelname := mux.Vars(r)["labelname"]
+
+	txn, err := transaction.NewTxnWithLocks(ctx, labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+	defer txn.Done()
+
+	if labelname == (label.DefaultLabel).Name {
+		errMsg := "Default label cannot be edited."
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, errMsg)
+		return
+	}
+
+	labelInfo, err := label.GetLabel(labelname)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	labelInfo, err = updateSetLabel(labelInfo, &req)
+	if err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, err)
+		return
+	}
+
+	if err := validateLabel(labelInfo); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, err)
+		return
+	}
+
+	txn.Steps = []*transaction.Step{
+		{
+			DoFunc: "label-config.Store",
+			Nodes:  []uuid.UUID{gdctx.MyUUID},
+		},
+	}
+
+	if err = txn.Ctx.Set("label", labelInfo); err != nil {
+		logger.WithError(err).Error("failed to set request in transaction context")
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	if err = txn.Do(); err != nil {
+		logger.WithError(err).Error("label config transaction failed")
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	labelInfo, err = label.GetLabel(labelname)
+	if err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+
+	txn.Ctx.Logger().WithField("LabelName", labelname).Info("label modfied")
+
+	resp := createLabelConfigResp(labelInfo)
+	restutils.SetLocationHeader(r, w, labelInfo.Name)
+	restutils.SendHTTPResponse(ctx, w, http.StatusOK, resp)
+}
+
+func createLabelConfigResp(info *label.Info) *api.LabelConfigResp {
+	return (*api.LabelConfigResp)(label.CreateLabelInfoResp(info))
+}
diff --git a/glusterd2/commands/snapshot/snapshot-create.go b/glusterd2/commands/snapshot/snapshot-create.go
index e85c284ce..b6b4e2061 100644
--- a/glusterd2/commands/snapshot/snapshot-create.go
+++ b/glusterd2/commands/snapshot/snapshot-create.go
@@ -24,6 +24,7 @@ import (
 	restutils "github.com/gluster/glusterd2/glusterd2/servers/rest/utils"
 	"github.com/gluster/glusterd2/glusterd2/servers/sunrpc/dict"
 	"github.com/gluster/glusterd2/glusterd2/snapshot"
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
 	"github.com/gluster/glusterd2/glusterd2/snapshot/lvm"
 	"github.com/gluster/glusterd2/glusterd2/transaction"
 	"github.com/gluster/glusterd2/glusterd2/volgen"
@@ -39,8 +40,15 @@ import (
 )
 
 type txnData struct {
-	Req       api.SnapCreateReq
-	CreatedAt time.Time
+	Req        api.SnapCreateReq
+	CreatedAt  time.Time
+	AutoDelete bool
+	Victim     snapshot.Snapinfo
+}
+
+type configTxnData struct {
+	AutoDeleteStatus bool
+	ActivateStatus   bool
 }
 
 func barrierActivateDeactivateFunc(volinfo *volume.Volinfo, option string, originUUID uuid.UUID) error {
@@ -210,22 +218,58 @@ func undoStoreSnapshotOnCreate(c transaction.TxnCtx) error {
 		return err
 	}
 
+	//As of now rollbacking for deleted snapshot is not implemented
+
 	return nil
 }
 
 // storeSnapshot uses to store the volinfo and to generate client volfile
 func storeSnapshotCreate(c transaction.TxnCtx) error {
 
-	var snapInfo snapshot.Snapinfo
+	var (
+		snapInfo   snapshot.Snapinfo
+		configData configTxnData
+		data       txnData
+	)
+
+	AutoDeleteStatus := false
+	ActivateStatus := false
+
 	if err := c.Get("snapinfo", &snapInfo); err != nil {
 		return err
 	}
 	volinfo := &snapInfo.SnapVolinfo
 
+	if err := c.Get("data", &data); err != nil {
+		return err
+	}
+
+	labelInfo, err := label.GetLabel(snapInfo.SnapLabel)
+	if err != nil {
+		c.Logger().WithError(err).WithField(
+			"label", snapInfo.SnapLabel).Debug("getLabel: failed to fetch label from store")
+		return err
+	}
+	if labelInfo.ActivateOnCreate || data.AutoDelete {
+		AutoDeleteStatus = false
+		ActivateStatus = false
+		for _, node := range volinfo.Nodes() {
+			if err := c.GetNodeResult(node, snapshot.NodeConfigTxnKey, &configData); err != nil {
+				return err
+			}
+			if !configData.ActivateStatus {
+				ActivateStatus = false
+			}
+			if !configData.AutoDeleteStatus {
+				AutoDeleteStatus = false
+			}
+		}
+	}
+
 	vol, err := volume.GetVolume(snapInfo.ParentVolume)
 	if err != nil {
 		c.Logger().WithError(err).WithField(
-			"volume", snapInfo.ParentVolume).Debug("storeVolume: failed to fetch Volinfo from store")
+			"volume", snapInfo.ParentVolume).Debug("getVolume: failed to fetch Volinfo from store")
 		return err
 	}
 
@@ -236,6 +280,30 @@ func storeSnapshotCreate(c transaction.TxnCtx) error {
 		return err
 	}
 
+	if AutoDeleteStatus {
+		victimVol := data.Victim.SnapVolinfo
+		if err := snapshot.DeleteSnapshot(&data.Victim); err != nil {
+			return err
+		}
+
+		if err := volgen.DeleteVolfiles(victimVol.VolfileID); err != nil {
+			c.Logger().WithError(err).
+				WithField("snapshot", snapshot.GetStorePath(&data.Victim)).
+				Warn("failed to delete volfiles of snapshot")
+			return err
+		}
+	}
+
+	labelInfo.SnapList = append(labelInfo.SnapList, volinfo.Name)
+	if err := label.AddOrUpdateLabelFunc(labelInfo); err != nil {
+		c.Logger().WithError(err).WithField(
+			"label", labelInfo.Name).Debug("storeLabel: failed to store Label")
+		return err
+	}
+
+	if ActivateStatus {
+		volinfo.State = volume.VolStarted
+	}
 	if err := snapshot.AddOrUpdateSnapFunc(&snapInfo); err != nil {
 		c.Logger().WithError(err).WithField(
 			"volume", volinfo.Name).Debug("storeSnapshot: failed to store snapshot info")
@@ -250,6 +318,75 @@ func storeSnapshotCreate(c transaction.TxnCtx) error {
 	return nil
 }
 
+func activateOnCreateSnapshot(snapinfo *snapshot.Snapinfo, logger log.FieldLogger) error {
+
+	vol := &snapinfo.SnapVolinfo
+
+	brickinfos, err := snapshot.GetOfflineBricks(vol)
+	if err != nil {
+		logger.WithError(err).Error("failed to get offline Bricks")
+		return err
+	}
+
+	err = snapshot.ActivateDeactivateFunc(snapinfo, brickinfos, true, logger)
+	return err
+}
+
+func snapshotLabelActions(c transaction.TxnCtx) error {
+
+	var (
+		snapInfo   snapshot.Snapinfo
+		data       txnData
+		configData configTxnData
+	)
+
+	if err := c.Get("snapinfo", &snapInfo); err != nil {
+		return err
+	}
+
+	if err := c.Get("data", &data); err != nil {
+		return err
+	}
+
+	labelInfo, err := label.GetLabel(snapInfo.SnapLabel)
+	if err != nil {
+		return err
+	}
+
+	configData.ActivateStatus = false
+	configData.AutoDeleteStatus = false
+	if labelInfo.ActivateOnCreate {
+		// Generate local Bricks Volfiles
+		vol := &snapInfo.SnapVolinfo
+		err = volgen.GenerateBricksVolfiles(vol, vol.GetLocalBricks())
+		if err != nil {
+			c.Logger().WithError(err).WithFields(log.Fields{
+				"template": "brick",
+				"volume":   vol.Name,
+			}).Error("failed to generate brick volfiles")
+			return err
+		}
+
+		if err := activateOnCreateSnapshot(&snapInfo, c.Logger()); err != nil {
+			c.Logger().WithError(err).WithField(
+				"snapshot", snapInfo.SnapVolinfo.Name).Debug("Failed to activate the snapshot")
+		} else {
+			configData.ActivateStatus = true
+		}
+	}
+	if data.AutoDelete {
+		if err := snapshotDelete(&data.Victim, c.Logger()); err != nil {
+			c.Logger().WithError(err).WithField(
+				"snapshot", snapInfo.SnapVolinfo.Name).Debug("Failed to delete the snapshot")
+		} else {
+			configData.AutoDeleteStatus = true
+		}
+	}
+	c.SetNodeResult(gdctx.MyUUID, snapshot.NodeConfigTxnKey, &configData)
+
+	return nil
+}
+
 func unmarshalSnapCreateRequest(msg *api.SnapCreateReq, r *http.Request) error {
 	if err := restutils.UnmarshalRequest(r, msg); err != nil {
 		return gderrors.ErrJSONParsingFailed
@@ -611,6 +748,7 @@ func createSnapinfo(c transaction.TxnCtx) error {
 
 	snapInfo.Description = req.Description
 	snapInfo.ParentVolume = req.VolName
+	snapInfo.SnapLabel = req.SnapLabel
 	/*
 		Snapshot time would be a good addition ?
 	*/
@@ -658,6 +796,39 @@ func snapshotBrickCreate(snapName, volName, brickDirSuffix string, subvolNumber,
 	return brickPath
 }
 
+func validateSnapLimits(info *label.Info, data *txnData) error {
+
+	if uint64(len(info.SnapList)) >= info.SnapMaxHardLimit {
+
+		err := fmt.Errorf("Maximum Hard Limit reached for label %s", info.Name)
+		msg := fmt.Sprintf("The number of existing snaps has reached the effective maximum limit of %v for the label (%s). Please delete few snapshots before taking further snapshots.", info.SnapMaxHardLimit, info.Name)
+
+		log.WithError(err).WithField("label", info.Name).Error(msg)
+		return err
+	}
+
+	if uint64(len(info.SnapList)+1) >= info.SnapMaxSoftLimit {
+		if info.AutoDelete {
+			//victim is the oldest snap name in the label list
+			victim, err := snapshot.GetSnapshot(info.SnapList[0])
+			if err != nil {
+				log.WithError(err).WithField("label", info.Name).Errorf("Unable to retrieve snapinfo from store for snapshot %s, which is scheduled to delete", info.SnapList[0])
+				return err
+			}
+			data.AutoDelete = true
+			data.Victim = *victim
+
+		} else {
+
+			msg := fmt.Sprintf("The number of snapshots will reach the effective maximum soft limit of %v for the label (%s). Please consider deleting older snapshots.", info.SnapMaxSoftLimit, info.Name)
+
+			log.WithField("volume", info.Name).Warn(msg)
+		}
+	}
+
+	return nil
+}
+
 func validateOriginNodeSnapCreate(c transaction.TxnCtx) error {
 	var data txnData
 
@@ -712,6 +883,7 @@ func registerSnapCreateStepFuncs() {
 		{"snap-create.DeactivateBarrier", deactivateBarrier},
 		{"snap-create.StoreSnapshot", storeSnapshotCreate},
 		{"snap-create.UndoStoreSnapshotOnCreate", undoStoreSnapshotOnCreate},
+		{"snap-create.LabelConfig", snapshotLabelActions},
 	}
 	for _, sf := range sfs {
 		transaction.RegisterStepFunc(sf.sf, sf.name)
@@ -719,13 +891,16 @@ func registerSnapCreateStepFuncs() {
 }
 
 func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
+	var (
+		data      txnData
+		labelInfo *label.Info
+	)
+
 	ctx := r.Context()
 	ctx, span := trace.StartSpan(ctx, "/snapshotCreateHandler")
 	defer span.End()
 
 	logger := gdctx.GetReqLogger(ctx)
-	var snapInfo snapshot.Snapinfo
-	var data txnData
 	req := &data.Req
 
 	err := unmarshalSnapCreateRequest(req, r)
@@ -743,8 +918,12 @@ func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
 		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, gderrors.ErrInvalidSnapName)
 		return
 	}
+	if req.SnapLabel == "" {
+		labelInfo = &label.DefaultLabel
+		req.SnapLabel = labelInfo.Name
+	}
 
-	txn, err := transaction.NewTxnWithLocks(ctx, req.VolName, req.SnapName)
+	txn, err := transaction.NewTxnWithLocks(ctx, req.VolName, req.SnapName, req.SnapLabel)
 	if err != nil {
 		status, err := restutils.ErrToStatusCode(err)
 		restutils.SendHTTPError(ctx, w, status, err)
@@ -752,6 +931,18 @@ func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	defer txn.Done()
 
+	labelInfo, err = label.GetLabel(req.SnapLabel)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
+		return
+	}
+
+	if err := validateSnapLimits(labelInfo, &data); err != nil {
+		restutils.SendHTTPError(ctx, w, http.StatusUnprocessableEntity, err)
+		return
+	}
+
 	if err = txn.Ctx.Set("data", data); err != nil {
 		logger.WithError(err).Error("failed to set request in transaction context")
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
@@ -769,6 +960,27 @@ func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if data.AutoDelete {
+		//If victim is selected as part of auto-delete then
+		//we need to take additional lock on snapshot name
+		//Lock on parent volume only requires if victim is for another volume
+
+		victim := &data.Victim
+		if req.VolName != victim.ParentVolume {
+			if err := txn.Lock(victim.ParentVolume); err != nil {
+				status, err := restutils.ErrToStatusCode(err)
+				restutils.SendHTTPError(ctx, w, status, err)
+				return
+			}
+		}
+		if err := txn.Lock(victim.SnapVolinfo.Name); err != nil {
+			status, err := restutils.ErrToStatusCode(err)
+			restutils.SendHTTPError(ctx, w, status, err)
+			return
+		}
+	}
+
+	startLabelAction := labelInfo.ActivateOnCreate || data.AutoDelete
 	txn.Nodes = vol.Nodes()
 	txn.Steps = []*transaction.Step{
 		{
@@ -795,6 +1007,11 @@ func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
 			Nodes:  txn.Nodes,
 		},
 
+		{
+			DoFunc: "snap-create.LabelConfig",
+			Nodes:  txn.Nodes,
+			Skip:   !startLabelAction,
+		},
 		{
 			DoFunc:   "snap-create.StoreSnapshot",
 			UndoFunc: "snap-create.UndoStoreSnapshotOnCreate",
@@ -817,13 +1034,14 @@ func snapshotCreateHandler(w http.ResponseWriter, r *http.Request) {
 
 	txn.Ctx.Logger().WithField("SnapName", req.SnapName).Info("new snapshot created")
 
-	if err = txn.Ctx.Get("snapinfo", &snapInfo); err != nil {
-		logger.WithError(err).Error("failed to get snap volinfo in transaction context")
-		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+	snapInfo, err := snapshot.GetSnapshot(req.SnapName)
+	if err != nil {
+		status, err := restutils.ErrToStatusCode(err)
+		restutils.SendHTTPError(ctx, w, status, err)
 		return
 	}
 
-	resp := createSnapCreateResp(&snapInfo)
+	resp := createSnapCreateResp(snapInfo)
 	restutils.SetLocationHeader(r, w, snapInfo.SnapVolinfo.Name)
 	restutils.SendHTTPResponse(ctx, w, http.StatusCreated, resp)
 }
@@ -841,5 +1059,6 @@ func createSnapInfoResp(snap *snapshot.Snapinfo) *api.SnapInfo {
 		ParentVolName: snap.ParentVolume,
 		Description:   snap.Description,
 		CreatedAt:     snap.CreatedAt,
+		SnapLabel:     snap.SnapLabel,
 	}
 }
diff --git a/glusterd2/commands/snapshot/snapshot-delete.go b/glusterd2/commands/snapshot/snapshot-delete.go
index 4825dee1e..09036bcd0 100644
--- a/glusterd2/commands/snapshot/snapshot-delete.go
+++ b/glusterd2/commands/snapshot/snapshot-delete.go
@@ -49,11 +49,7 @@ func snapshotBrickDelete(errCh chan error, wg *sync.WaitGroup, snapVol volume.Vo
 	return
 }
 
-func snapshotDelete(c transaction.TxnCtx) error {
-	var snapinfo snapshot.Snapinfo
-	if err := c.Get("snapinfo", &snapinfo); err != nil {
-		return err
-	}
+func snapshotDelete(snapinfo *snapshot.Snapinfo, logger log.FieldLogger) error {
 
 	snapVol := snapinfo.SnapVolinfo
 	var wg sync.WaitGroup
@@ -62,7 +58,7 @@ func snapshotDelete(c transaction.TxnCtx) error {
 
 	for _, b := range snapVol.GetLocalBricks() {
 		wg.Add(1)
-		go snapshotBrickDelete(errCh, &wg, snapVol, b, c.Logger())
+		go snapshotBrickDelete(errCh, &wg, snapVol, b, logger)
 	}
 
 	err := error(nil)
@@ -77,7 +73,15 @@ func snapshotDelete(c transaction.TxnCtx) error {
 	wg.Wait()
 	close(errCh)
 
-	//TODO Delete the volfiles in etcd.
+	return err
+}
+
+func snapshotDeletetxn(c transaction.TxnCtx) error {
+	var snapinfo snapshot.Snapinfo
+	if err := c.Get("snapinfo", &snapinfo); err != nil {
+		return err
+	}
+	err := snapshotDelete(&snapinfo, c.Logger())
 	return err
 }
 
@@ -114,7 +118,7 @@ func registerSnapDeleteStepFuncs() {
 		name string
 		sf   transaction.StepFunc
 	}{
-		{"snap-delete.Commit", snapshotDelete},
+		{"snap-delete.Commit", snapshotDeletetxn},
 		{"snap-delete.Store", snapshotDeleteStore},
 		/*
 			TODO
@@ -143,7 +147,7 @@ func snapshotDeleteHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	txn, err := transaction.NewTxnWithLocks(ctx, snapname, snapinfo.ParentVolume)
+	txn, err := transaction.NewTxnWithLocks(ctx, snapname, snapinfo.ParentVolume, snapinfo.SnapLabel)
 	if err != nil {
 		status, err := restutils.ErrToStatusCode(err)
 		restutils.SendHTTPError(ctx, w, status, err)
diff --git a/glusterd2/commands/snapshot/snapshot-restore.go b/glusterd2/commands/snapshot/snapshot-restore.go
index e76086f9f..e0d68b5c2 100644
--- a/glusterd2/commands/snapshot/snapshot-restore.go
+++ b/glusterd2/commands/snapshot/snapshot-restore.go
@@ -360,7 +360,7 @@ func snapshotRestoreHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	txn, err := transaction.NewTxnWithLocks(ctx, snapname, snapinfo.ParentVolume)
+	txn, err := transaction.NewTxnWithLocks(ctx, snapname, snapinfo.ParentVolume, snapinfo.SnapLabel)
 	if err != nil {
 		status, err := restutils.ErrToStatusCode(err)
 		restutils.SendHTTPError(ctx, w, status, err)
diff --git a/glusterd2/main.go b/glusterd2/main.go
index 5406eb262..8f95bfbaf 100644
--- a/glusterd2/main.go
+++ b/glusterd2/main.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/gluster/glusterd2/glusterd2/commands/snapshot"
 	"github.com/gluster/glusterd2/glusterd2/commands/volumes"
 	"github.com/gluster/glusterd2/glusterd2/daemon"
 	"github.com/gluster/glusterd2/glusterd2/events"
@@ -118,6 +119,11 @@ func main() {
 		log.WithError(err).Fatal("Failed to load the default group options")
 	}
 
+	// Initialize the default snapshot label into the store
+	if err := snapshotcommands.LoadDefaultLabel(); err != nil {
+		log.WithError(err).Fatal("Failed to load the default label")
+	}
+
 	// If REST API Auth is enabled, Generate Auth file with random secret in localstatedir
 	if err := gdctx.GenerateLocalAuthToken(); err != nil {
 		log.WithError(err).Fatal("Failed to generate local auth token")
diff --git a/glusterd2/servers/rest/utils/utils.go b/glusterd2/servers/rest/utils/utils.go
index 8eea0e697..1100db675 100644
--- a/glusterd2/servers/rest/utils/utils.go
+++ b/glusterd2/servers/rest/utils/utils.go
@@ -100,6 +100,8 @@ func ErrToStatusCode(err error) (int, error) {
 		statuscode = http.StatusNotFound
 	case gderrors.ErrSnapNotFound:
 		statuscode = http.StatusNotFound
+	case gderrors.ErrLabelNotFound:
+		statuscode = http.StatusNotFound
 	case transaction.ErrLockTimeout:
 		statuscode = http.StatusConflict
 	default:
diff --git a/glusterd2/snapshot/label/store-utils.go b/glusterd2/snapshot/label/store-utils.go
new file mode 100644
index 000000000..55132a7a2
--- /dev/null
+++ b/glusterd2/snapshot/label/store-utils.go
@@ -0,0 +1,114 @@
+package label
+
+import (
+	"context"
+	"encoding/json"
+
+	gdstore "github.com/gluster/glusterd2/glusterd2/store"
+	gderror "github.com/gluster/glusterd2/pkg/errors"
+
+	"github.com/coreos/etcd/clientv3"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	labelPrefix string = "labels/"
+)
+
+var (
+	//ExistsFunc check whether a given label exist or not
+	ExistsFunc = Exists
+	// AddOrUpdateLabelFunc marshals to label object and passes to store to add/update
+	AddOrUpdateLabelFunc = AddOrUpdateLabel
+)
+
+//Exists check whether a given label exist or not
+func Exists(name string) bool {
+	resp, e := gdstore.Get(context.TODO(), labelPrefix+name)
+	if e != nil {
+		return false
+	}
+
+	return resp.Count == 1
+}
+
+//GetLabels retrives the json objects from the store and converts them into
+//respective Info objects
+func GetLabels() ([]*Info, error) {
+	resp, e := gdstore.Get(context.TODO(), labelPrefix, clientv3.WithPrefix())
+	if e != nil {
+		return nil, e
+	}
+
+	labels := make([]*Info, len(resp.Kvs))
+	for i, kv := range resp.Kvs {
+		var label Info
+
+		if err := json.Unmarshal(kv.Value, &label); err != nil {
+			log.WithError(err).WithField("Label", string(kv.Key)).Error("Failed to unmarshal label")
+			continue
+		}
+
+		labels[i] = &label
+	}
+
+	return labels, nil
+}
+
+// AddOrUpdateLabel marshals to Label object and passes to store to add/update
+func AddOrUpdateLabel(labelInfo *Info) error {
+	json, e := json.Marshal(labelInfo)
+	if e != nil {
+		log.WithError(e).Error("Failed to marshal the labelinfo object")
+		return e
+	}
+
+	_, e = gdstore.Put(context.TODO(), GetStorePath(labelInfo), string(json))
+	if e != nil {
+		log.WithError(e).Error("Couldn't add label to store")
+		return e
+	}
+	return nil
+}
+
+// GetLabel fetches the json object from the store and unmarshalls it into
+// Info object
+func GetLabel(name string) (*Info, error) {
+	var labelinfo Info
+
+	resp, e := gdstore.Get(context.TODO(), labelPrefix+name)
+	if e != nil {
+		log.WithError(e).Error("Couldn't retrive volume from store")
+		return nil, e
+	}
+
+	if resp.Count != 1 {
+		log.WithField("label", name).Error("label not found")
+		return nil, gderror.ErrLabelNotFound
+	}
+
+	if e = json.Unmarshal(resp.Kvs[0].Value, &labelinfo); e != nil {
+		log.WithError(e).Error("Failed to unmarshal the data into labelinfo object")
+		return nil, e
+	}
+	return &labelinfo, nil
+}
+
+//DeleteLabel passes the label path to store to delete the label object
+func DeleteLabel(labelInfo *Info) error {
+	_, e := gdstore.Delete(context.TODO(), GetStorePath(labelInfo))
+	if e != nil {
+		return e
+	}
+
+	/*
+		TODO
+		Delete all object tagged to this label
+	*/
+	return e
+}
+
+//GetStorePath return label path for etcd store
+func GetStorePath(labelInfo *Info) string {
+	return labelPrefix + labelInfo.Name
+}
diff --git a/glusterd2/snapshot/label/structs.go b/glusterd2/snapshot/label/structs.go
new file mode 100644
index 000000000..5e9bbd3c1
--- /dev/null
+++ b/glusterd2/snapshot/label/structs.go
@@ -0,0 +1,37 @@
+//Package label that contains struct for label
+package label
+
+//Options is used as key to set Label info values
+type Options string
+
+const (
+	//SnapMaxHardLimitKey is used to set the value SnapMaxHardLimit
+	SnapMaxHardLimitKey Options = "snap-max-hard-limit"
+	//SnapMaxSoftLimitKey is used to set the value SnapMaxSoftLimit
+	SnapMaxSoftLimitKey Options = "snap-max-soft-limit"
+	//ActivateOnCreateKey is used to set the value ActivateOnCreate
+	ActivateOnCreateKey Options = "activate-on-create"
+	//AutoDeleteKey is used to set the value AutoDelete
+	AutoDeleteKey Options = "auto-delete"
+)
+
+//Info is used to represent a label
+type Info struct {
+	Name             string
+	SnapMaxHardLimit uint64
+	SnapMaxSoftLimit uint64
+	ActivateOnCreate bool
+	AutoDelete       bool
+	Description      string
+	SnapList         []string
+}
+
+//DefaultLabel contains default values for a label
+var DefaultLabel = Info{
+	ActivateOnCreate: false,
+	AutoDelete:       false,
+	Description:      "This is a default label",
+	Name:             "defaultLabel",
+	SnapMaxHardLimit: 256,
+	SnapMaxSoftLimit: 230,
+}
diff --git a/glusterd2/snapshot/label/utils.go b/glusterd2/snapshot/label/utils.go
new file mode 100644
index 000000000..6a1cc019f
--- /dev/null
+++ b/glusterd2/snapshot/label/utils.go
@@ -0,0 +1,20 @@
+package label
+
+import (
+	"github.com/gluster/glusterd2/pkg/api"
+)
+
+//CreateLabelInfoResp parses volume information for response
+func CreateLabelInfoResp(info *Info) *api.LabelInfo {
+
+	resp := &api.LabelInfo{
+		Name:             info.Name,
+		SnapMaxHardLimit: info.SnapMaxHardLimit,
+		SnapMaxSoftLimit: info.SnapMaxSoftLimit,
+		ActivateOnCreate: info.ActivateOnCreate,
+		AutoDelete:       info.AutoDelete,
+		Description:      info.Description,
+		SnapList:         info.SnapList,
+	}
+	return resp
+}
diff --git a/glusterd2/snapshot/snapshot-utils.go b/glusterd2/snapshot/snapshot-utils.go
index d4210a79b..d19c3690e 100644
--- a/glusterd2/snapshot/snapshot-utils.go
+++ b/glusterd2/snapshot/snapshot-utils.go
@@ -33,6 +33,8 @@ type BrickMountData struct {
 var (
 	//NodeDataTxnKey is used for storing the status
 	NodeDataTxnKey = "brickmountstatus"
+	//NodeConfigTxnKey is used for storing the config status
+	NodeConfigTxnKey = "snapshotconfigstatus"
 )
 
 func getOnlineOfflineBricks(vol *volume.Volinfo, online bool) ([]brick.Brickinfo, error) {
diff --git a/glusterd2/snapshot/store-utils.go b/glusterd2/snapshot/store-utils.go
index e3cf87ec3..82eb71d14 100644
--- a/glusterd2/snapshot/store-utils.go
+++ b/glusterd2/snapshot/store-utils.go
@@ -6,6 +6,7 @@ import (
 	"errors"
 	"strings"
 
+	"github.com/gluster/glusterd2/glusterd2/snapshot/label"
 	gdstore "github.com/gluster/glusterd2/glusterd2/store"
 	"github.com/gluster/glusterd2/glusterd2/volume"
 
@@ -137,7 +138,6 @@ func DeleteSnapshot(snapInfo *Snapinfo) error {
 		return e
 	}
 
-	//TODO change this when label based snapshots are in.
 	e = errors.New("snap is not found in the volinfo")
 	for key, entry := range vol.SnapList {
 		if strings.Compare(entry, snapInfo.SnapVolinfo.Name) == 0 {
@@ -147,6 +147,20 @@ func DeleteSnapshot(snapInfo *Snapinfo) error {
 		}
 	}
 
+	labelInfo, e := label.GetLabel(snapInfo.SnapLabel)
+	if e != nil {
+		return e
+	}
+
+	e = errors.New("snap is not found in the Label")
+	for key, entry := range labelInfo.SnapList {
+		if strings.Compare(entry, snapInfo.SnapVolinfo.Name) == 0 {
+			labelInfo.SnapList = append(labelInfo.SnapList[:key], labelInfo.SnapList[key+1:]...)
+			e = label.AddOrUpdateLabelFunc(labelInfo)
+			break
+		}
+	}
+
 	return e
 }
 
diff --git a/glusterd2/snapshot/structs.go b/glusterd2/snapshot/structs.go
index 6b7720166..d5c72fa8d 100644
--- a/glusterd2/snapshot/structs.go
+++ b/glusterd2/snapshot/structs.go
@@ -14,4 +14,5 @@ type Snapinfo struct {
 	Description  string
 	OptionChange map[string]string
 	CreatedAt    time.Time
+	SnapLabel    string
 }
diff --git a/pkg/api/labels_req.go b/pkg/api/labels_req.go
new file mode 100644
index 000000000..7df355392
--- /dev/null
+++ b/pkg/api/labels_req.go
@@ -0,0 +1,21 @@
+package api
+
+// LabelCreateReq represents a lebel Create Request
+type LabelCreateReq struct {
+	Name             string `json:"labelname"`
+	SnapMaxHardLimit uint64 `json:"snap-max-hard-limit"`
+	SnapMaxSoftLimit uint64 `json:"snap-max-soft-limit"`
+	ActivateOnCreate bool   `json:"activate-on-create,omitempty"`
+	AutoDelete       bool   `json:"auto-delete,omitempty"`
+	Description      string `json:"description,omitempty"`
+}
+
+// LabelSetReq represents a lebel Create Request
+type LabelSetReq struct {
+	Configurations map[string]string `json:"configurations"`
+}
+
+// LabelResetReq represents a lebel Create Request
+type LabelResetReq struct {
+	Configurations []string `json:"configurations"`
+}
diff --git a/pkg/api/labels_resp.go b/pkg/api/labels_resp.go
new file mode 100644
index 000000000..232433f48
--- /dev/null
+++ b/pkg/api/labels_resp.go
@@ -0,0 +1,24 @@
+package api
+
+// LabelInfo contains static information of a label
+type LabelInfo struct {
+	Name             string   `json:"labelname"`
+	SnapMaxHardLimit uint64   `json:"snap-max-hard-limit"`
+	SnapMaxSoftLimit uint64   `json:"snap-max-soft-limit"`
+	ActivateOnCreate bool     `json:"activate-on-create"`
+	AutoDelete       bool     `json:"auto-delete"`
+	Description      string   `json:"description"`
+	SnapList         []string `json:"snap-list"`
+}
+
+//LabelCreateResp is the response sent for a label get request.
+type LabelCreateResp LabelInfo
+
+//LabelGetResp is the response sent for a label get request.
+type LabelGetResp LabelInfo
+
+//LabelListResp is the response sent for a label list request.
+type LabelListResp []LabelGetResp
+
+//LabelConfigResp is the response sent for a label config request.
+type LabelConfigResp LabelInfo
diff --git a/pkg/api/snapshot_req.go b/pkg/api/snapshot_req.go
index 777584af5..f99b0ae20 100644
--- a/pkg/api/snapshot_req.go
+++ b/pkg/api/snapshot_req.go
@@ -7,6 +7,7 @@ type SnapCreateReq struct {
 	TimeStamp   bool   `json:"timestamp,omitempty"`
 	Description string `json:"description,omitempty"`
 	Force       bool   `json:"force,omitempty"`
+	SnapLabel   string `json:"label"`
 }
 
 //SnapActivateReq represents a request to activate a snapshot
diff --git a/pkg/api/snapshot_resp.go b/pkg/api/snapshot_resp.go
index 695d8611f..e63116071 100644
--- a/pkg/api/snapshot_resp.go
+++ b/pkg/api/snapshot_resp.go
@@ -13,6 +13,7 @@ type SnapInfo struct {
 	ParentVolName string     `json:"parentname"`
 	Description   string     `json:"description"`
 	CreatedAt     time.Time  `json:"created-at"`
+	SnapLabel     string     `json:"label"`
 }
 
 //SnapList contains snapshots information of a volume.
diff --git a/pkg/errors/error.go b/pkg/errors/error.go
index 92dee920d..58157e9e5 100644
--- a/pkg/errors/error.go
+++ b/pkg/errors/error.go
@@ -59,4 +59,6 @@ var (
 	ErrInvalidVolFileTmplNamespace = errors.New("invalid template namespace")
 	ErrInvalidVolFileTmplName      = errors.New("invalid template name")
 	ErrDeviceNameNotFound          = errors.New("device name not found")
+	ErrLabelNotFound               = errors.New("label not found")
+	ErrLabelExists                 = errors.New("label already exists")
 )
diff --git a/pkg/restclient/label.go b/pkg/restclient/label.go
new file mode 100644
index 000000000..152c28459
--- /dev/null
+++ b/pkg/restclient/label.go
@@ -0,0 +1,50 @@
+package restclient
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gluster/glusterd2/pkg/api"
+)
+
+// LabelCreate creates Gluster Label
+func (c *Client) LabelCreate(req api.LabelCreateReq) (api.LabelCreateResp, error) {
+	var labelinfo api.LabelCreateResp
+	err := c.post("/v1/snapshots/labels/create", req, http.StatusCreated, &labelinfo)
+	return labelinfo, err
+}
+
+//LabelSet will change its values to default.
+func (c *Client) LabelSet(req api.LabelSetReq, labelname string) error {
+	url := fmt.Sprintf("/v1/snapshots/labels/%s/config", labelname)
+	return c.post(url, req, http.StatusOK, nil)
+}
+
+//LabelReset will allow to modify its values.
+func (c *Client) LabelReset(req api.LabelResetReq, labelname string) error {
+	url := fmt.Sprintf("/v1/snapshots/labels/%s/config", labelname)
+	return c.del(url, req, http.StatusOK, nil)
+}
+
+// LabelList returns list of all labels
+func (c *Client) LabelList() (api.LabelListResp, error) {
+	var labelinfos api.LabelListResp
+	err := c.get("/v1/snapshots/labels/list/all", nil, http.StatusOK, &labelinfos)
+	return labelinfos, err
+}
+
+// LabelInfo returns information about a label
+func (c *Client) LabelInfo(labelname string) (api.LabelGetResp, error) {
+	var labelinfo api.LabelGetResp
+	var url string
+	url = fmt.Sprintf("/v1/snapshots/labels/%s", labelname)
+	err := c.get(url, nil, http.StatusOK, &labelinfo)
+	return labelinfo, err
+}
+
+// LabelDelete will delete Gluster Label and respective lv
+func (c *Client) LabelDelete(labelname string) error {
+	url := fmt.Sprintf("/v1/snapshots/labels/%s", labelname)
+	err := c.del(url, nil, http.StatusNoContent, nil)
+	return err
+}