diff --git a/adapter/outbound/base.go b/adapter/outbound/base.go
index ab7fd24b..0aa8dfc5 100644
--- a/adapter/outbound/base.go
+++ b/adapter/outbound/base.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"github.com/gofrs/uuid"
 	"net"
 
 	"github.com/Dreamacro/clash/component/dialer"
@@ -17,6 +18,7 @@ type Base struct {
 	tp    C.AdapterType
 	udp   bool
 	rmark int
+	id    string
 }
 
 // Name implements C.ProxyAdapter
@@ -24,6 +26,20 @@ func (b *Base) Name() string {
 	return b.name
 }
 
+// Id implements C.ProxyAdapter
+func (b *Base) Id() string {
+	if b.id == "" {
+		id, err := uuid.NewV6()
+		if err != nil {
+			b.id = b.name
+		} else {
+			b.id = id.String()
+		}
+	}
+
+	return b.id
+}
+
 // Type implements C.ProxyAdapter
 func (b *Base) Type() C.AdapterType {
 	return b.tp
@@ -58,6 +74,7 @@ func (b *Base) SupportUDP() bool {
 func (b *Base) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]string{
 		"type": b.Type().String(),
+		"id":   b.Id(),
 	})
 }
 
diff --git a/constant/rule_extra.go b/constant/rule_extra.go
index a115319f..f13ec0bb 100644
--- a/constant/rule_extra.go
+++ b/constant/rule_extra.go
@@ -46,3 +46,11 @@ func (re *RuleExtra) NotMatchProcessName(processName string) bool {
 type RuleGeoSite interface {
 	GetDomainMatcher() *router.DomainMatcher
 }
+
+type RuleGeoIP interface {
+	GetIPMatcher() *router.GeoIPMatcher
+}
+
+type RuleGroup interface {
+	GetRecodeSize() int
+}
diff --git a/hub/route/rules.go b/hub/route/rules.go
index 52615abc..de4c9f11 100644
--- a/hub/route/rules.go
+++ b/hub/route/rules.go
@@ -1,6 +1,7 @@
 package route
 
 import (
+	"github.com/Dreamacro/clash/constant"
 	"net/http"
 
 	"github.com/Dreamacro/clash/tunnel"
@@ -19,17 +20,23 @@ type Rule struct {
 	Type    string `json:"type"`
 	Payload string `json:"payload"`
 	Proxy   string `json:"proxy"`
+	Size    int    `json:"Size"`
 }
 
 func getRules(w http.ResponseWriter, r *http.Request) {
 	rawRules := tunnel.Rules()
 	rules := []Rule{}
 	for _, rule := range rawRules {
-		rules = append(rules, Rule{
+		r := Rule{
 			Type:    rule.RuleType().String(),
 			Payload: rule.Payload(),
 			Proxy:   rule.Adapter(),
-		})
+			Size:    -1,
+		}
+		if rule.RuleType() == constant.GEOIP || rule.RuleType() == constant.GEOSITE {
+			r.Size = rule.(constant.RuleGroup).GetRecodeSize()
+		}
+		rules = append(rules, r)
 
 	}
 
diff --git a/rule/common/geoip.go b/rule/common/geoip.go
index e3127e23..aeddcbdb 100644
--- a/rule/common/geoip.go
+++ b/rule/common/geoip.go
@@ -18,6 +18,7 @@ type GEOIP struct {
 	adapter      string
 	noResolveIP  bool
 	geoIPMatcher *router.GeoIPMatcher
+	recodeSize   int
 }
 
 func (g *GEOIP) RuleType() C.RuleType {
@@ -65,6 +66,10 @@ func (g *GEOIP) GetIPMatcher() *router.GeoIPMatcher {
 	return g.geoIPMatcher
 }
 
+func (g *GEOIP) GetRecodeSize() int {
+	return g.recodeSize
+}
+
 func NewGEOIP(country string, adapter string, noResolveIP bool) (*GEOIP, error) {
 	if !C.GeodataMode {
 		geoip := &GEOIP{
@@ -76,18 +81,19 @@ func NewGEOIP(country string, adapter string, noResolveIP bool) (*GEOIP, error)
 		return geoip, nil
 	}
 
-	geoIPMatcher, recordsCount, err := geodata.LoadGeoIPMatcher(country)
+	geoIPMatcher, size, err := geodata.LoadGeoIPMatcher(country)
 	if err != nil {
 		return nil, fmt.Errorf("[GeoIP] %s", err.Error())
 	}
 
-	log.Infoln("Start initial GeoIP rule %s => %s, records: %d", country, adapter, recordsCount)
+	log.Infoln("Start initial GeoIP rule %s => %s, records: %d", country, adapter, size)
 	geoip := &GEOIP{
 		Base:         &Base{},
 		country:      country,
 		adapter:      adapter,
 		noResolveIP:  noResolveIP,
 		geoIPMatcher: geoIPMatcher,
+		recodeSize:   size,
 	}
 	return geoip, nil
 }
diff --git a/rule/common/geosite.go b/rule/common/geosite.go
index 8087403b..3e6fbe42 100644
--- a/rule/common/geosite.go
+++ b/rule/common/geosite.go
@@ -14,9 +14,10 @@ import (
 
 type GEOSITE struct {
 	*Base
-	country string
-	adapter string
-	matcher *router.DomainMatcher
+	country    string
+	adapter    string
+	matcher    *router.DomainMatcher
+	recodeSize int
 }
 
 func (gs *GEOSITE) RuleType() C.RuleType {
@@ -44,19 +45,24 @@ func (gs *GEOSITE) GetDomainMatcher() *router.DomainMatcher {
 	return gs.matcher
 }
 
+func (gs *GEOSITE) GetRecodeSize() int {
+	return gs.recodeSize
+}
+
 func NewGEOSITE(country string, adapter string) (*GEOSITE, error) {
-	matcher, recordsCount, err := geodata.LoadGeoSiteMatcher(country)
+	matcher, size, err := geodata.LoadGeoSiteMatcher(country)
 	if err != nil {
 		return nil, fmt.Errorf("load GeoSite data error, %s", err.Error())
 	}
 
-	log.Infoln("Start initial GeoSite rule %s => %s, records: %d", country, adapter, recordsCount)
+	log.Infoln("Start initial GeoSite rule %s => %s, records: %d", country, adapter, size)
 
 	geoSite := &GEOSITE{
-		Base:    &Base{},
-		country: country,
-		adapter: adapter,
-		matcher: matcher,
+		Base:       &Base{},
+		country:    country,
+		adapter:    adapter,
+		matcher:    matcher,
+		recodeSize: size,
 	}
 
 	return geoSite, nil