diff --git a/handlers/exploration.go b/handlers/exploration.go
index b0fe971ea..b24ca1f7d 100644
--- a/handlers/exploration.go
+++ b/handlers/exploration.go
@@ -14,19 +14,19 @@ import (
 	op "github.com/influxdata/chronograf/restapi/operations"
 )
 
-func (h *Store) Explorations(ctx context.Context, params op.GetSourcesIDUsersUserIDExplorationsParams) middleware.Responder {
+func (h *Store) Explorations(ctx context.Context, params op.GetUsersUserIDExplorationsParams) middleware.Responder {
 	uID, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		log.Printf("Error: Unable to convert UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert UserID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
 	}
 
 	mrExs, err := h.ExplorationStore.Query(ctx, chronograf.UserID(uID))
 	if err != nil {
 		log.Printf("Error: Unknown response from store while querying UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unknown response from store while querying UserID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
 	}
 
 	exs := make([]*models.Exploration, len(mrExs))
@@ -47,35 +47,35 @@ func (h *Store) Explorations(ctx context.Context, params op.GetSourcesIDUsersUse
 	res := &models.Explorations{
 		Explorations: exs,
 	}
-	return op.NewGetSourcesIDUsersUserIDExplorationsOK().WithPayload(res)
+	return op.NewGetUsersUserIDExplorationsOK().WithPayload(res)
 }
 
-func (h *Store) Exploration(ctx context.Context, params op.GetSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (h *Store) Exploration(ctx context.Context, params op.GetUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	eID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
 		log.Printf("Error: Unable to convert ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert ExplorationID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	uID, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		log.Printf("Error: Unable to convert UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert UserID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	e, err := h.ExplorationStore.Get(ctx, chronograf.ExplorationID(eID))
 	if err != nil {
 		log.Printf("Error: Unknown ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error: Unknown ExplorationID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 
 	if e.UserID != chronograf.UserID(uID) {
 		log.Printf("Error: Unknown ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error: Unknown ExplorationID"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 
 	rel := "self"
@@ -90,42 +90,42 @@ func (h *Store) Exploration(ctx context.Context, params op.GetSourcesIDUsersUser
 			Href: &href,
 		},
 	}
-	return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDOK().WithPayload(res)
+	return op.NewGetUsersUserIDExplorationsExplorationIDOK().WithPayload(res)
 }
 
-func (h *Store) UpdateExploration(ctx context.Context, params op.PatchSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (h *Store) UpdateExploration(ctx context.Context, params op.PatchUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	if params.Exploration == nil {
 		log.Printf("Error: Exploration is nil")
 		errMsg := &models.Error{Code: 400, Message: "Error: Exploration is nil"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(400).WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(400).WithPayload(errMsg)
 	}
 
 	eID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
 		log.Printf("Error: Unable to convert ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert ExplorationID"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	uID, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		log.Printf("Error: Unable to convert UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert UserID"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	e, err := h.ExplorationStore.Get(ctx, chronograf.ExplorationID(eID))
 	if err != nil || e.UserID != chronograf.UserID(uID) {
 		log.Printf("Error: Unknown ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error: Unknown ExplorationID"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 	if params.Exploration.Data != nil {
 		var ok bool
 		if e.Data, ok = params.Exploration.Data.(string); !ok {
 			log.Printf("Error: Exploration data is not a string")
 			errMsg := &models.Error{Code: 400, Message: "Error: Exploration data is not a string"}
-			return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(400).WithPayload(errMsg)
+			return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(400).WithPayload(errMsg)
 		}
 	}
 
@@ -136,10 +136,10 @@ func (h *Store) UpdateExploration(ctx context.Context, params op.PatchSourcesIDU
 	if err := h.ExplorationStore.Update(ctx, e); err != nil {
 		log.Printf("Error: Failed to update Exploration: %v: %v", e, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Failed to update Exploration"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
-	return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDOK().WithPayload(explToModel(e))
+	return op.NewPatchUsersUserIDExplorationsExplorationIDOK().WithPayload(explToModel(e))
 }
 
 func explToModel(e *chronograf.Exploration) *models.Exploration {
@@ -157,18 +157,18 @@ func explToModel(e *chronograf.Exploration) *models.Exploration {
 	}
 }
 
-func (h *Store) NewExploration(ctx context.Context, params op.PostSourcesIDUsersUserIDExplorationsParams) middleware.Responder {
+func (h *Store) NewExploration(ctx context.Context, params op.PostUsersUserIDExplorationsParams) middleware.Responder {
 	if params.Exploration == nil {
 		log.Printf("Error: Exploration is nil")
 		errMsg := &models.Error{Code: 400, Message: "Error: Exploration is nil"}
-		return op.NewPostSourcesIDUsersUserIDExplorationsDefault(400).WithPayload(errMsg)
+		return op.NewPostUsersUserIDExplorationsDefault(400).WithPayload(errMsg)
 	}
 
 	uID, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		log.Printf("Error: Unable to convert UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert UserID"}
-		return op.NewPostSourcesIDUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
+		return op.NewPostUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
 	}
 
 	// TODO: Check user if user exists.
@@ -187,40 +187,40 @@ func (h *Store) NewExploration(ctx context.Context, params op.PostSourcesIDUsers
 	if err != nil {
 		log.Printf("Error: Failed to save Exploration: %v: %v", e, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Failed to save Exploration"}
-		return op.NewPostSourcesIDUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
+		return op.NewPostUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
 	}
 
 	m := explToModel(e)
-	res := op.NewPostSourcesIDUsersUserIDExplorationsCreated()
+	res := op.NewPostUsersUserIDExplorationsCreated()
 	return res.WithLocation(*m.Link.Href).WithPayload(m)
 }
 
-func (h *Store) DeleteExploration(ctx context.Context, params op.DeleteSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (h *Store) DeleteExploration(ctx context.Context, params op.DeleteUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	eID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
 		log.Printf("Error: Unable to convert ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert ExplorationID"}
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	uID, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		log.Printf("Error: Unable to convert UserID: %s: %v", params.UserID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Unable to convert UserID"}
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	e, err := h.ExplorationStore.Get(ctx, chronograf.ExplorationID(eID))
 	if err != nil || e.UserID != chronograf.UserID(uID) {
 		log.Printf("Error: Unknown ExplorationID: %s: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error: Unknown ExplorationID"}
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 
 	if err := h.ExplorationStore.Delete(ctx, &chronograf.Exploration{ID: chronograf.ExplorationID(eID)}); err != nil {
 		log.Printf("Error: Failed to delete Exploration: %v: %v", params.ExplorationID, err)
 		errMsg := &models.Error{Code: 500, Message: "Error: Failed to delete Exploration"}
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
-	return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDNoContent()
+	return op.NewDeleteUsersUserIDExplorationsExplorationIDNoContent()
 }
diff --git a/mock/handlers.go b/mock/handlers.go
index e09098ab2..63b9656cd 100644
--- a/mock/handlers.go
+++ b/mock/handlers.go
@@ -216,14 +216,14 @@ func (m *Handler) Proxy(ctx context.Context, params op.PostSourcesIDProxyParams)
 	return op.NewPostSourcesIDProxyOK().WithPayload(res)
 }
 
-func (m *Handler) Explorations(ctx context.Context, params op.GetSourcesIDUsersUserIDExplorationsParams) middleware.Responder {
+func (m *Handler) Explorations(ctx context.Context, params op.GetUsersUserIDExplorationsParams) middleware.Responder {
 	id, err := strconv.Atoi(params.UserID)
 	if err != nil {
-		return op.NewGetSourcesIDUsersUserIDExplorationsDefault(500)
+		return op.NewGetUsersUserIDExplorationsDefault(500)
 	}
 	exs, err := m.Store.Query(ctx, chronograf.UserID(id))
 	if err != nil {
-		return op.NewGetSourcesIDUsersUserIDExplorationsNotFound()
+		return op.NewGetUsersUserIDExplorationsNotFound()
 	}
 	res := &models.Explorations{}
 	for i, e := range exs {
@@ -241,27 +241,27 @@ func (m *Handler) Explorations(ctx context.Context, params op.GetSourcesIDUsersU
 		},
 		)
 	}
-	return op.NewGetSourcesIDUsersUserIDExplorationsOK().WithPayload(res)
+	return op.NewGetUsersUserIDExplorationsOK().WithPayload(res)
 }
 
-func (m *Handler) Exploration(ctx context.Context, params op.GetSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (m *Handler) Exploration(ctx context.Context, params op.GetUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	id, err := strconv.Atoi(params.UserID)
 	if err != nil {
 		errMsg := &models.Error{Code: 500, Message: "Error converting user id"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsDefault(500).WithPayload(errMsg)
 	}
 
 	eID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
 		errMsg := &models.Error{Code: 500, Message: "Error converting exploration id"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDDefault(500).WithPayload(errMsg)
 	}
 
 	e, err := m.Store.Get(ctx, chronograf.ExplorationID(eID))
 	if err != nil {
 		log.Printf("Error unknown exploration id: %d: %v", eID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error unknown exploration id"}
-		return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewGetUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 
 	rel := "self"
@@ -276,20 +276,20 @@ func (m *Handler) Exploration(ctx context.Context, params op.GetSourcesIDUsersUs
 			Href: &href,
 		},
 	}
-	return op.NewGetSourcesIDUsersUserIDExplorationsExplorationIDOK().WithPayload(res)
+	return op.NewGetUsersUserIDExplorationsExplorationIDOK().WithPayload(res)
 }
 
-func (m *Handler) UpdateExploration(ctx context.Context, params op.PatchSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (m *Handler) UpdateExploration(ctx context.Context, params op.PatchUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	eID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDDefault(500)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDDefault(500)
 	}
 
 	e, err := m.Store.Get(ctx, chronograf.ExplorationID(eID))
 	if err != nil {
 		log.Printf("Error unknown exploration id: %d: %v", eID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error unknown exploration id"}
-		return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewPatchUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
 	if params.Exploration != nil {
 		e.ID = chronograf.ExplorationID(eID)
@@ -297,20 +297,20 @@ func (m *Handler) UpdateExploration(ctx context.Context, params op.PatchSourcesI
 		e.Name = params.Exploration.Name
 		m.Store.Update(ctx, e)
 	}
-	return op.NewPatchSourcesIDUsersUserIDExplorationsExplorationIDOK()
+	return op.NewPatchUsersUserIDExplorationsExplorationIDOK()
 }
 
-func (m *Handler) NewExploration(ctx context.Context, params op.PostSourcesIDUsersUserIDExplorationsParams) middleware.Responder {
+func (m *Handler) NewExploration(ctx context.Context, params op.PostUsersUserIDExplorationsParams) middleware.Responder {
 	id, err := strconv.Atoi(params.UserID)
 	if err != nil {
-		return op.NewPostSourcesIDUsersUserIDExplorationsDefault(500)
+		return op.NewPostUsersUserIDExplorationsDefault(500)
 	}
 
 	exs, err := m.Store.Query(ctx, chronograf.UserID(id))
 	if err != nil {
 		log.Printf("Error unknown user id: %d: %v", id, err)
 		errMsg := &models.Error{Code: 404, Message: "Error unknown user id"}
-		return op.NewPostSourcesIDUsersUserIDExplorationsNotFound().WithPayload(errMsg)
+		return op.NewPostUsersUserIDExplorationsNotFound().WithPayload(errMsg)
 	}
 	eID := len(exs)
 
@@ -333,22 +333,22 @@ func (m *Handler) NewExploration(ctx context.Context, params op.PostSourcesIDUse
 		Rel:  &rel,
 	}
 	params.Exploration.Link = link
-	return op.NewPostSourcesIDUsersUserIDExplorationsCreated().WithPayload(params.Exploration).WithLocation(loc)
+	return op.NewPostUsersUserIDExplorationsCreated().WithPayload(params.Exploration).WithLocation(loc)
 
 }
 
-func (m *Handler) DeleteExploration(ctx context.Context, params op.DeleteSourcesIDUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
+func (m *Handler) DeleteExploration(ctx context.Context, params op.DeleteUsersUserIDExplorationsExplorationIDParams) middleware.Responder {
 	ID, err := strconv.Atoi(params.ExplorationID)
 	if err != nil {
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDDefault(500)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDDefault(500)
 	}
 
 	if err := m.Store.Delete(ctx, &chronograf.Exploration{ID: chronograf.ExplorationID(ID)}); err != nil {
 		log.Printf("Error unknown explorations id: %d: %v", ID, err)
 		errMsg := &models.Error{Code: 404, Message: "Error unknown user id"}
-		return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
+		return op.NewDeleteUsersUserIDExplorationsExplorationIDNotFound().WithPayload(errMsg)
 	}
-	return op.NewDeleteSourcesIDUsersUserIDExplorationsExplorationIDNoContent()
+	return op.NewDeleteUsersUserIDExplorationsExplorationIDNoContent()
 }
 
 func (m *Handler) GetMappings(ctx context.Context, params op.GetMappingsParams) middleware.Responder {