diff --git a/pkg/services/ngalert/api/api_alertmanager.go b/pkg/services/ngalert/api/api_alertmanager.go
index f1c4f0ceb2a..cd3218bb7e2 100644
--- a/pkg/services/ngalert/api/api_alertmanager.go
+++ b/pkg/services/ngalert/api/api_alertmanager.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/go-openapi/strfmt"
+	"github.com/grafana/alerting/alerting"
 
 	"github.com/grafana/grafana/pkg/api/response"
 	"github.com/grafana/grafana/pkg/infra/log"
@@ -76,11 +77,11 @@ func (srv AlertmanagerSrv) RouteCreateSilence(c *models.ReqContext, postableSile
 
 	silenceID, err := am.CreateSilence(&postableSilence)
 	if err != nil {
-		if errors.Is(err, notifier.ErrSilenceNotFound) {
+		if errors.Is(err, alerting.ErrSilenceNotFound) {
 			return ErrResp(http.StatusNotFound, err, "")
 		}
 
-		if errors.Is(err, notifier.ErrCreateSilenceBadPayload) {
+		if errors.Is(err, alerting.ErrCreateSilenceBadPayload) {
 			return ErrResp(http.StatusBadRequest, err, "")
 		}
 
@@ -112,7 +113,7 @@ func (srv AlertmanagerSrv) RouteDeleteSilence(c *models.ReqContext, silenceID st
 	}
 
 	if err := am.DeleteSilence(silenceID); err != nil {
-		if errors.Is(err, notifier.ErrSilenceNotFound) {
+		if errors.Is(err, alerting.ErrSilenceNotFound) {
 			return ErrResp(http.StatusNotFound, err, "")
 		}
 		return ErrResp(http.StatusInternalServerError, err, "")
@@ -190,7 +191,7 @@ func (srv AlertmanagerSrv) RouteGetSilence(c *models.ReqContext, silenceID strin
 
 	gettableSilence, err := am.GetSilence(silenceID)
 	if err != nil {
-		if errors.Is(err, notifier.ErrSilenceNotFound) {
+		if errors.Is(err, alerting.ErrSilenceNotFound) {
 			return ErrResp(http.StatusNotFound, err, "")
 		}
 		// any other error here should be an unexpected failure and thus an internal error
@@ -207,7 +208,7 @@ func (srv AlertmanagerSrv) RouteGetSilences(c *models.ReqContext) response.Respo
 
 	gettableSilences, err := am.ListSilences(c.QueryStrings("filter"))
 	if err != nil {
-		if errors.Is(err, notifier.ErrListSilencesBadPayload) {
+		if errors.Is(err, alerting.ErrListSilencesBadPayload) {
 			return ErrResp(http.StatusBadRequest, err, "")
 		}
 		// any other error here should be an unexpected failure and thus an internal error
diff --git a/pkg/services/ngalert/notifier/silences.go b/pkg/services/ngalert/notifier/silences.go
index 17c6051c026..23840ea7d77 100644
--- a/pkg/services/ngalert/notifier/silences.go
+++ b/pkg/services/ngalert/notifier/silences.go
@@ -5,31 +5,25 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/grafana/alerting/alerting"
+
 	apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
 	v2 "github.com/prometheus/alertmanager/api/v2"
 	"github.com/prometheus/alertmanager/silence"
 )
 
-var (
-	ErrGetSilencesInternal     = fmt.Errorf("unable to retrieve silence(s) due to an internal error")
-	ErrDeleteSilenceInternal   = fmt.Errorf("unable to delete silence due to an internal error")
-	ErrCreateSilenceBadPayload = fmt.Errorf("unable to create silence")
-	ErrListSilencesBadPayload  = fmt.Errorf("unable to list silences")
-	ErrSilenceNotFound         = silence.ErrNotFound
-)
-
 // ListSilences retrieves a list of stored silences. It supports a set of labels as filters.
 func (am *Alertmanager) ListSilences(filter []string) (apimodels.GettableSilences, error) {
 	matchers, err := parseFilter(filter)
 	if err != nil {
 		am.logger.Error("failed to parse matchers", "error", err)
-		return nil, fmt.Errorf("%s: %w", ErrListSilencesBadPayload.Error(), err)
+		return nil, fmt.Errorf("%s: %w", alerting.ErrListSilencesBadPayload.Error(), err)
 	}
 
 	psils, _, err := am.silences.Query()
 	if err != nil {
-		am.logger.Error(ErrGetSilencesInternal.Error(), "error", err)
-		return nil, fmt.Errorf("%s: %w", ErrGetSilencesInternal.Error(), err)
+		am.logger.Error(alerting.ErrGetSilencesInternal.Error(), "error", err)
+		return nil, fmt.Errorf("%s: %w", alerting.ErrGetSilencesInternal.Error(), err)
 	}
 
 	sils := apimodels.GettableSilences{}
@@ -41,7 +35,7 @@ func (am *Alertmanager) ListSilences(filter []string) (apimodels.GettableSilence
 		if err != nil {
 			am.logger.Error("unmarshaling from protobuf failed", "error", err)
 			return apimodels.GettableSilences{}, fmt.Errorf("%s: failed to convert internal silence to API silence: %w",
-				ErrGetSilencesInternal.Error(), err)
+				alerting.ErrGetSilencesInternal.Error(), err)
 		}
 		sils = append(sils, &silence)
 	}
@@ -55,19 +49,19 @@ func (am *Alertmanager) ListSilences(filter []string) (apimodels.GettableSilence
 func (am *Alertmanager) GetSilence(silenceID string) (apimodels.GettableSilence, error) {
 	sils, _, err := am.silences.Query(silence.QIDs(silenceID))
 	if err != nil {
-		return apimodels.GettableSilence{}, fmt.Errorf("%s: %w", ErrGetSilencesInternal.Error(), err)
+		return apimodels.GettableSilence{}, fmt.Errorf("%s: %w", alerting.ErrGetSilencesInternal.Error(), err)
 	}
 
 	if len(sils) == 0 {
 		am.logger.Error("failed to find silence", "error", err, "id", sils)
-		return apimodels.GettableSilence{}, ErrSilenceNotFound
+		return apimodels.GettableSilence{}, alerting.ErrSilenceNotFound
 	}
 
 	sil, err := v2.GettableSilenceFromProto(sils[0])
 	if err != nil {
 		am.logger.Error("unmarshaling from protobuf failed", "error", err)
 		return apimodels.GettableSilence{}, fmt.Errorf("%s: failed to convert internal silence to API silence: %w",
-			ErrGetSilencesInternal.Error(), err)
+			alerting.ErrGetSilencesInternal.Error(), err)
 	}
 
 	return sil, nil
@@ -79,28 +73,28 @@ func (am *Alertmanager) CreateSilence(ps *apimodels.PostableSilence) (string, er
 	if err != nil {
 		am.logger.Error("marshaling to protobuf failed", "error", err)
 		return "", fmt.Errorf("%s: failed to convert API silence to internal silence: %w",
-			ErrCreateSilenceBadPayload.Error(), err)
+			alerting.ErrCreateSilenceBadPayload.Error(), err)
 	}
 
 	if sil.StartsAt.After(sil.EndsAt) || sil.StartsAt.Equal(sil.EndsAt) {
 		msg := "start time must be before end time"
 		am.logger.Error(msg, "error", "starts_at", sil.StartsAt, "ends_at", sil.EndsAt)
-		return "", fmt.Errorf("%s: %w", msg, ErrCreateSilenceBadPayload)
+		return "", fmt.Errorf("%s: %w", msg, alerting.ErrCreateSilenceBadPayload)
 	}
 
 	if sil.EndsAt.Before(time.Now()) {
 		msg := "end time can't be in the past"
 		am.logger.Error(msg, "ends_at", sil.EndsAt)
-		return "", fmt.Errorf("%s: %w", msg, ErrCreateSilenceBadPayload)
+		return "", fmt.Errorf("%s: %w", msg, alerting.ErrCreateSilenceBadPayload)
 	}
 
 	silenceID, err := am.silences.Set(sil)
 	if err != nil {
 		am.logger.Error("msg", "unable to save silence", "error", err)
 		if errors.Is(err, silence.ErrNotFound) {
-			return "", ErrSilenceNotFound
+			return "", alerting.ErrSilenceNotFound
 		}
-		return "", fmt.Errorf("unable to save silence: %s: %w", err.Error(), ErrCreateSilenceBadPayload)
+		return "", fmt.Errorf("unable to save silence: %s: %w", err.Error(), alerting.ErrCreateSilenceBadPayload)
 	}
 
 	return silenceID, nil
@@ -110,9 +104,9 @@ func (am *Alertmanager) CreateSilence(ps *apimodels.PostableSilence) (string, er
 func (am *Alertmanager) DeleteSilence(silenceID string) error {
 	if err := am.silences.Expire(silenceID); err != nil {
 		if errors.Is(err, silence.ErrNotFound) {
-			return ErrSilenceNotFound
+			return alerting.ErrSilenceNotFound
 		}
-		return fmt.Errorf("%s: %w", err.Error(), ErrDeleteSilenceInternal)
+		return fmt.Errorf("%s: %w", err.Error(), alerting.ErrDeleteSilenceInternal)
 	}
 
 	return nil