diff --git a/backend/app/store/engine/bolt.go b/backend/app/store/engine/bolt.go
index e4aa2567..7fbf8048 100644
--- a/backend/app/store/engine/bolt.go
+++ b/backend/app/store/engine/bolt.go
@@ -322,14 +322,14 @@ func (b *BoltDB) Info(req InfoRequest) ([]store.PostInfo, error) {
 
 // ListFlags get list of flagged keys, like blocked & verified user
 // works for full locator (post flags) or with userID
-func (b *BoltDB) ListFlags(siteID string, flag Flag) (res []interface{}, err error) {
+func (b *BoltDB) ListFlags(req FlagRequest) (res []interface{}, err error) {
 
-	bdb, e := b.db(siteID)
+	bdb, e := b.db(req.Locator.SiteID)
 	if e != nil {
 		return nil, e
 	}
 
-	switch flag {
+	switch req.Flag {
 	case Verified:
 		err = bdb.View(func(tx *bolt.Tx) error {
 			usersBkt := tx.Bucket([]byte(verifiedBucketName))
@@ -351,7 +351,7 @@ func (b *BoltDB) ListFlags(siteID string, flag Flag) (res []interface{}, err err
 				if time.Now().Before(ts) {
 					// get user name from comment user section
 					userName := ""
-					req := FindRequest{Locator: store.Locator{SiteID: siteID}, UserID: string(k), Limit: 1}
+					req := FindRequest{Locator: store.Locator{SiteID: req.Locator.SiteID}, UserID: string(k), Limit: 1}
 					userComments, errUser := b.Find(req)
 					if errUser == nil && len(userComments) > 0 {
 						userName = userComments[0].User.Name
@@ -363,7 +363,7 @@ func (b *BoltDB) ListFlags(siteID string, flag Flag) (res []interface{}, err err
 		})
 		return res, err
 	}
-	return nil, errors.Errorf("flag %s not listable", flag)
+	return nil, errors.Errorf("flag %s not listable", req.Flag)
 }
 
 // Delete post(s) by id or by userID
diff --git a/backend/app/store/engine/bolt_test.go b/backend/app/store/engine/bolt_test.go
index 502fcb8d..5bbeecf4 100644
--- a/backend/app/store/engine/bolt_test.go
+++ b/backend/app/store/engine/bolt_test.go
@@ -530,17 +530,17 @@ func TestBolt_FlagListVerified(t *testing.T) {
 		return err
 	}
 
-	ids, err := b.ListFlags("radio-t", Verified)
+	ids, err := b.ListFlags(FlagRequest{Flag: Verified, Locator: store.Locator{SiteID: "radio-t"}})
 	assert.NoError(t, err)
 	assert.Equal(t, []string{}, toIDs(ids), "verified list empty")
 
 	assert.NoError(t, setVerified("radio-t", "u1", FlagTrue))
 	assert.NoError(t, setVerified("radio-t", "u2", FlagTrue))
-	ids, err = b.ListFlags("radio-t", Verified)
+	ids, err = b.ListFlags(FlagRequest{Flag: Verified, Locator: store.Locator{SiteID: "radio-t"}})
 	assert.NoError(t, err)
 	assert.Equal(t, []string{"u1", "u2"}, toIDs(ids), "verified 2 ids")
 
-	_, err = b.ListFlags("radio-t-bad", Verified)
+	_, err = b.ListFlags(FlagRequest{Flag: Verified, Locator: store.Locator{SiteID: "radio-t-bad"}})
 	assert.Error(t, err, "site \"radio-t-bad\" not found", "fail on wrong site")
 }
 
@@ -568,7 +568,7 @@ func TestBolt_FlagListBlocked(t *testing.T) {
 	assert.NoError(t, setBlocked("radio-t", "user2", FlagTrue, 50*time.Millisecond))
 	assert.NoError(t, setBlocked("radio-t", "user3", FlagFalse, 0))
 
-	vv, err := b.ListFlags("radio-t", Blocked)
+	vv, err := b.ListFlags(FlagRequest{Flag: Blocked, Locator: store.Locator{SiteID: "radio-t"}})
 	assert.NoError(t, err)
 
 	blockedList := toBlocked(vv)
@@ -579,13 +579,13 @@ func TestBolt_FlagListBlocked(t *testing.T) {
 
 	// check block expiration
 	time.Sleep(50 * time.Millisecond)
-	vv, err = b.ListFlags("radio-t", Blocked)
+	vv, err = b.ListFlags(FlagRequest{Flag: Blocked, Locator: store.Locator{SiteID: "radio-t"}})
 	assert.NoError(t, err)
 	blockedList = toBlocked(vv)
 	assert.Equal(t, 1, len(blockedList))
 	assert.Equal(t, "user1", blockedList[0].ID)
 
-	_, err = b.ListFlags("bad", Blocked)
+	_, err = b.ListFlags(FlagRequest{Flag: Blocked, Locator: store.Locator{SiteID: "bad"}})
 	assert.EqualError(t, err, `site "bad" not found`)
 
 }
diff --git a/backend/app/store/engine/engine.go b/backend/app/store/engine/engine.go
index cd618fe2..db46d646 100644
--- a/backend/app/store/engine/engine.go
+++ b/backend/app/store/engine/engine.go
@@ -24,7 +24,7 @@ type Interface interface {
 	Count(req FindRequest) (int, error)                                 // get count for post or user
 	Delete(req DeleteRequest) error                                     // delete post(s) by id or by userID
 	Flag(req FlagRequest) (bool, error)                                 // set and get flags
-	ListFlags(siteID string, flag Flag) ([]interface{}, error)          // get list of flagged keys, like blocked & verified user
+	ListFlags(req FlagRequest) ([]interface{}, error)                   // get list of flagged keys, like blocked & verified user
 	Close() error                                                       // close storage engine
 }
 
diff --git a/backend/app/store/engine/engine_mock.go b/backend/app/store/engine/engine_mock.go
index 38496094..2c1437f7 100644
--- a/backend/app/store/engine/engine_mock.go
+++ b/backend/app/store/engine/engine_mock.go
@@ -167,13 +167,13 @@ func (_m *MockInterface) Info(req InfoRequest) ([]store.PostInfo, error) {
 	return r0, r1
 }
 
-// ListFlags provides a mock function with given fields: siteID, flag
-func (_m *MockInterface) ListFlags(siteID string, flag Flag) ([]interface{}, error) {
-	ret := _m.Called(siteID, flag)
+// ListFlags provides a mock function with given fields: req
+func (_m *MockInterface) ListFlags(req FlagRequest) ([]interface{}, error) {
+	ret := _m.Called(req)
 
 	var r0 []interface{}
-	if rf, ok := ret.Get(0).(func(string, Flag) []interface{}); ok {
-		r0 = rf(siteID, flag)
+	if rf, ok := ret.Get(0).(func(FlagRequest) []interface{}); ok {
+		r0 = rf(req)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]interface{})
@@ -181,8 +181,8 @@ func (_m *MockInterface) ListFlags(siteID string, flag Flag) ([]interface{}, err
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(string, Flag) error); ok {
-		r1 = rf(siteID, flag)
+	if rf, ok := ret.Get(1).(func(FlagRequest) error); ok {
+		r1 = rf(req)
 	} else {
 		r1 = ret.Error(1)
 	}
diff --git a/backend/app/store/engine/remote.go b/backend/app/store/engine/remote.go
index 997b9492..6ae52102 100644
--- a/backend/app/store/engine/remote.go
+++ b/backend/app/store/engine/remote.go
@@ -72,8 +72,8 @@ func (r *Remote) Flag(req FlagRequest) (status bool, err error) {
 }
 
 // ListFlags get list of flagged keys, like blocked & verified user
-func (r *Remote) ListFlags(siteID string, flag Flag) (list []interface{}, err error) {
-	resp, err := r.Call("list_flags", siteID, flag)
+func (r *Remote) ListFlags(req FlagRequest) (list []interface{}, err error) {
+	resp, err := r.Call("list_flags", req)
 	if err != nil {
 		return nil, err
 	}
diff --git a/backend/app/store/engine/remote_test.go b/backend/app/store/engine/remote_test.go
index eadb7fff..eae18300 100644
--- a/backend/app/store/engine/remote_test.go
+++ b/backend/app/store/engine/remote_test.go
@@ -125,11 +125,11 @@ func TestClient_Flag(t *testing.T) {
 }
 
 func TestClient_ListFlag(t *testing.T) {
-	ts := testServer(t, `{"method":"list_flags","params":["site_id","blocked"],"id":1}`,
+	ts := testServer(t, `{"method":"list_flags","params":{"flag":"blocked","locator":{"site":"site_id","url":""}},"id":1}`,
 		`{"result":[{"ID":"id1"},{"ID":"id2"}]}`)
 	defer ts.Close()
 	c := Remote{Client: remote.Client{API: ts.URL, Client: http.Client{}}}
-	res, err := c.ListFlags("site_id", Blocked)
+	res, err := c.ListFlags(FlagRequest{Locator: store.Locator{SiteID: "site_id"}, Flag: Blocked})
 	assert.NoError(t, err)
 	assert.Equal(t, []interface{}{map[string]interface{}{"ID": "id1"}, map[string]interface{}{"ID": "id2"}}, res)
 }
diff --git a/backend/app/store/service/service.go b/backend/app/store/service/service.go
index 7a0acc88..32e34ef6 100644
--- a/backend/app/store/service/service.go
+++ b/backend/app/store/service/service.go
@@ -523,7 +523,7 @@ func (s *DataStore) SetBlock(siteID string, userID string, status bool, ttl time
 
 // Blocked returns list with all blocked users
 func (s *DataStore) Blocked(siteID string) (res []store.BlockedUser, err error) {
-	blocked, e := s.Engine.ListFlags(siteID, engine.Blocked)
+	blocked, e := s.Engine.ListFlags(engine.FlagRequest{Locator: store.Locator{SiteID: siteID}, Flag: engine.Blocked})
 	if e != nil {
 		return nil, errors.Wrapf(err, "can't get list of blocked users for %s", siteID)
 	}
@@ -606,7 +606,7 @@ func (s *DataStore) Metas(siteID string) (umetas []UserMetaData, pmetas []PostMe
 	}
 
 	// process verified users
-	verified, err := s.Engine.ListFlags(siteID, engine.Verified)
+	verified, err := s.Engine.ListFlags(engine.FlagRequest{Locator: store.Locator{SiteID: siteID}, Flag: engine.Verified})
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "can't get list of verified users for %s", siteID)
 	}